Condividi tramite


Receive-Job

Ottiene i risultati dei processi in background di PowerShell nella sessione corrente.

Sintassi

Receive-Job
       [-Job] <Job[]>
       [[-Location] <string[]>]
       [-Keep]
       [-NoRecurse]
       [-Force]
       [-Wait]
       [-AutoRemoveJob]
       [-WriteEvents]
       [-WriteJobInResults]
       [<CommonParameters>]
Receive-Job
       [-Job] <Job[]>
       [[-ComputerName] <string[]>]
       [-Keep]
       [-NoRecurse]
       [-Force]
       [-Wait]
       [-AutoRemoveJob]
       [-WriteEvents]
       [-WriteJobInResults]
       [<CommonParameters>]
Receive-Job
       [-Job] <Job[]>
       [[-Session] <PSSession[]>]
       [-Keep]
       [-NoRecurse]
       [-Force]
       [-Wait]
       [-AutoRemoveJob]
       [-WriteEvents]
       [-WriteJobInResults]
       [<CommonParameters>]
Receive-Job
       [-Name] <string[]>
       [-Keep]
       [-NoRecurse]
       [-Force]
       [-Wait]
       [-AutoRemoveJob]
       [-WriteEvents]
       [-WriteJobInResults]
       [<CommonParameters>]
Receive-Job
       [-InstanceId] <guid[]>
       [-Keep]
       [-NoRecurse]
       [-Force]
       [-Wait]
       [-AutoRemoveJob]
       [-WriteEvents]
       [-WriteJobInResults]
       [<CommonParameters>]
Receive-Job
       [-Id] <int[]>
       [-Keep]
       [-NoRecurse]
       [-Force]
       [-Wait]
       [-AutoRemoveJob]
       [-WriteEvents]
       [-WriteJobInResults]
       [<CommonParameters>]

Descrizione

Il Receive-Job cmdlet ottiene i risultati dei processi in background di PowerShell, ad esempio quelli avviati usando il Start-Job cmdlet o il parametro AsJob di qualsiasi cmdlet. È possibile ottenere i risultati di tutti i processi o identificare i processi in base a nome, ID, ID istanza, nome computer, posizione o sessione oppure inviando un oggetto processo.

Quando si avvia un processo in background di PowerShell, il processo viene avviato, ma i risultati non vengono visualizzati immediatamente. Il comando restituisce invece un oggetto che rappresenta il processo in background. L'oggetto processo contiene informazioni utili sul processo, ma non contiene i risultati. Questo metodo consente di continuare a lavorare nella sessione durante l'esecuzione del processo. Per altre informazioni sui processi in background in PowerShell, vedere about_Jobs.

Il Receive-Job cmdlet ottiene i risultati generati dal momento in cui il Receive-Job comando viene inviato. Se i risultati non sono ancora stati completati, è possibile eseguire comandi aggiuntivi Receive-Job per ottenere i risultati rimanenti.

Per impostazione predefinita, i risultati del processo vengono eliminati dal sistema quando vengono ricevuti, ma è possibile usare il parametro Keep per salvare i risultati in modo da poterli ricevere di nuovo. Per eliminare i risultati del processo, eseguire di nuovo il Receive-Job comando senza il parametro Keep , chiudere la sessione o usare il Remove-Job cmdlet per eliminare il processo dalla sessione.

A partire da Windows PowerShell 3.0, Receive-Job ottiene anche i risultati dei tipi di processi personalizzati, ad esempio processi del flusso di lavoro e istanze di processi pianificati. Per consentire Receive-Job di ottenere i risultati di un tipo di processo personalizzato, importare il modulo che supporta il tipo di processo personalizzato nella sessione prima di eseguire un Receive-Job comando, usando il Import-Module cmdlet o ottenendo un cmdlet nel modulo. Per informazioni su un tipo di processo personalizzato particolare, vedere la documentazione relativa alla funzionalità del tipo di processo personalizzato.

Esempio

Esempio 1: Ottenere risultati per un determinato processo

$job = Start-Job -ScriptBlock {Get-Process}
Start-Sleep -Seconds 1
Receive-Job -Job $job

Questi comandi usano il parametro Job di Receive-Job per ottenere i risultati di un determinato processo.

Il primo comando avvia un processo con Start-Job e archivia l'oggetto processo nella $job variabile .

Il secondo comando usa il Receive-Job cmdlet per ottenere i risultati del processo. Usa il parametro Job per specificare il processo.

Esempio 2: Usare il parametro Keep

$job = Start-Job -ScriptBlock {Get-Service dhcp, fakeservice}
Start-Sleep -Seconds 1
$job | Receive-Job -Keep

Cannot find any service with service name 'fakeservice'.
    + CategoryInfo          : ObjectNotFound: (fakeservice:String) [Get-Service], ServiceCommandException
    + FullyQualifiedErrorId : NoServiceFoundForGivenName,Microsoft.PowerShell.Commands.GetServiceCommand
    + PSComputerName        : localhost

Status   Name               DisplayName
------   ----               -----------
Running  dhcp               DHCP Client

$job | Receive-Job -Keep

Cannot find any service with service name 'fakeservice'.
    + CategoryInfo          : ObjectNotFound: (fakeservice:String) [Get-Service], ServiceCommandException
    + FullyQualifiedErrorId : NoServiceFoundForGivenName,Microsoft.PowerShell.Commands.GetServiceCommand
    + PSComputerName        : localhost

Status   Name               DisplayName
------   ----               -----------
Running  dhcp               DHCP Client

Questo esempio archivia un processo nella $job variabile e invia tramite pipe il processo al Receive-Job cmdlet . Il -Keep parametro viene usato anche per consentire il recupero di tutti i dati del flusso aggregato dopo la prima visualizzazione.

Esempio 3: Ottenere i risultati di diversi processi in background

Quando si usa il parametro AsJob di Invoke-Command per avviare un processo, l'oggetto processo viene creato nel computer locale, anche se il processo viene eseguito nei computer remoti. Di conseguenza, per gestire il processo è possibile usare comandi locali.

Inoltre, quando si usa AsJob, PowerShell restituisce un oggetto processo che contiene un processo figlio per ogni processo avviato. In questo caso, l'oggetto processo contiene tre processi figlio, uno per ogni processo in ogni computer remoto.

# Use the Invoke-Command cmdlet with the -AsJob parameter to start a background job that
# runs a Get-Service command on three remote computers. Store the resulting job object in
# the $j variable
$j = Invoke-Command -ComputerName Server01, Server02, Server03 -ScriptBlock {Get-Service} -AsJob
# Display the value of the **ChildJobs** property of the job object in $j. The display
# shows that the command created three child jobs, one for the job on each remote
# computer. You could also use the -IncludeChildJobs parameter of the Get-Job cmdlet.
$j.ChildJobs

Id   Name     State      HasMoreData   Location       Command
--   ----     -----      -----------   --------       -------
2    Job2     Completed  True          Server01       Get-Service
3    Job3     Completed  True          Server02       Get-Service
4    Job4     Completed  True          Server03       Get-Service

# Use the Receive-Job cmdlet to get the results of just the Job3 child job that ran on the
# Server02 computer. Use the *Keep* parameter to allow you to view the aggregated stream
# data more than once.
Receive-Job -Name Job3 -Keep

Status  Name        DisplayName                        PSComputerName
------  ----------- -----------                        --------------
Running AeLookupSvc Application Experience             Server02
Stopped ALG         Application Layer Gateway Service  Server02
Running Appinfo     Application Information            Server02
Running AppMgmt     Application Management             Server02

Esempio 4: Ottenere i risultati dei processi in background in più computer remoti

# Use the New-PSSession cmdlet to create three user-managed PSSessions on three servers,
# and save the sessions in the $s variable.
$s = New-PSSession -ComputerName Server01, Server02, Server03
# Use Invoke-Command run a Start-Job command in each of the PSSessions in the $s variable.
# The code creates a new job with a custom name to each server. The job outputs the
# datetime from each server. Save the job objects in the $j variable.
$invokeCommandSplat = @{
    Session = $s
    ScriptBlock = {
        Start-Job -Name $('MyJob-' +$env:COMPUTERNAME) -ScriptBlock {
            (Get-Date).ToString()
        }
    }
}
$j = Invoke-Command @invokeCommandSplat
# To confirm that these job objects are from the remote machines, run Get-Job to show no
# local jobs running.
Get-Job`
# Display the three job objects in $j. Note that the Localhost location is not the local
# computer, but instead localhost as it relates to the job on each Server.
$j

Id   Name               State      HasMoreData   Location   Command
--   ----               -----      -----------   --------   -------
1    MyJob-Server01     Completed  True          Localhost  (Get-Date).ToString()
2    MyJob-Server02     Completed  True          Localhost  (Get-Date).ToString()
3    MyJob-Server03     Completed  True          Localhost  (Get-Date).ToString()

# Use Invoke-Command to run a Receive-Job command in each of the sessions in the $s
# variable and save the results in the $results variable. The Receive-Job command must be
# run in each session because the jobs were run locally on each server.
$results = Invoke-Command -Session $s -ScriptBlock {
    Receive-Job -Name $('MyJob-' +$env:COMPUTERNAME)
}

3/22/2021 7:41:47 PM
3/22/2021 7:41:47 PM
3/22/2021 9:41:47 PM

Questo esempio mostra come ottenere i risultati dei processi in background eseguiti in tre computer remoti. A differenza dell'esempio precedente, l'uso Invoke-Command di per eseguire il Start-Job comando ha effettivamente avviato tre processi indipendenti in ognuno dei tre computer. Di conseguenza, il comando ha restituito tre oggetti processo che rappresentano tre processi eseguiti localmente in tre computer diversi.

Esempio 5: Accedere ai processi figlio

Il -Keep parametro mantiene lo stato dei flussi aggregati di un processo in modo che possa essere nuovamente visualizzato. Senza questo parametro tutti i dati aggregati del flusso vengono cancellati quando viene ricevuto il processo. Per altre informazioni, vedere about_Job_Details

Nota

I flussi aggregati includono i flussi di tutti i processi figlio. È comunque possibile raggiungere i singoli flussi di dati tramite l'oggetto processo e gli oggetti processo figlio.

Start-Job -Name TestJob -ScriptBlock {dir C:\, Z:\}
# Without the Keep parameter, aggregated child job data is displayed once.
# Then destroyed.
Receive-Job -Name TestJob

Directory: C:\

Mode                LastWriteTime         Length Name
----                -------------         ------ ----
d-r---        1/24/2019   7:11 AM                Program Files
d-r---        2/13/2019   8:32 AM                Program Files (x86)
d-r---        10/3/2018  11:47 AM                Users
d-----         2/7/2019   1:52 AM                Windows
Cannot find drive. A drive with the name 'Z' does not exist.
    + CategoryInfo          : ObjectNotFound: (Z:String) [Get-ChildItem], DriveNotFoundException
    + FullyQualifiedErrorId : DriveNotFound,Microsoft.PowerShell.Commands.GetChildItemCommand
    + PSComputerName        : localhost

# It would seem that the child job data is gone.
Receive-Job -Name TestJob



# Using the object model, you can still retrieve child job data and streams.
$job = Get-Job -Name TestJob
$job.ChildJobs[0].Error

Cannot find drive. A drive with the name 'Z' does not exist.
    + CategoryInfo          : ObjectNotFound: (Z:String) [Get-ChildItem], DriveNotFoundException
    + FullyQualifiedErrorId : DriveNotFound,Microsoft.PowerShell.Commands.GetChildItemCommand
    + PSComputerName        : localhost

Parametri

-AutoRemoveJob

Indica che questo cmdlet elimina il processo dopo che restituisce i risultati del processo. Se il processo ha più risultati, il processo viene comunque eliminato, ma Receive-Job visualizza un messaggio.

Questo parametro funziona solo con tipi di processo personalizzati. È progettato per istanze di tipi di processo che salvano il processo o il tipo all'esterno della sessione, ad esempio istanze di processi pianificati.

Questo parametro non può essere usato senza il parametro Wait .

Questo parametro è stato introdotto in Windows PowerShell 3.0.

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

-ComputerName

Specifica una matrice di nomi di computer.

Questo parametro effettua la selezione nei risultati del processo archiviati nel computer locale. Non recupera i dati per i processi eseguiti nei computer remoti. Per ottenere i risultati dei processi archiviati in computer remoti, usare il Invoke-Command cmdlet per eseguire un Receive-Job comando in modalità remota.

Tipo:String[]
Alias:Cn
Posizione:1
Valore predefinito:All computers available
Necessario:False
Accettare l'input della pipeline:True
Accettare caratteri jolly:True

-Force

Indica che questo cmdlet continua ad attendere se i processi si trovano nello stato Suspended o Disconnected . Per impostazione predefinita, il parametro Wait di Receive-Job restituisce o termina l'attesa, quando i processi si trovano in uno degli stati seguenti:

  • Completato
  • Non riuscito
  • Arrestato
  • Suspended
  • Disconnesso

Il parametro Force è valido solo quando il parametro Wait viene usato anche nel comando .

Questo parametro è stato introdotto in Windows PowerShell 3.0.

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

-Id

Specifica una matrice di ID. Questo cmdlet ottiene i risultati dei processi con gli ID specificati.

L'ID è un numero intero che identifica in modo univoco il processo nella sessione corrente. è più facile ricordare e digitare l'ID istanza, ma è univoco solo nella sessione corrente. È possibile digitare uno o più ID separati da virgole. Per trovare l'ID di un processo, usare Get-Job.

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

-InstanceId

Specifica una matrice di ID istanza. Questo cmdlet ottiene i risultati dei processi con gli ID istanza specificati.

Un ID istanza è un GUID che identifica in modo univoco il processo nel computer. Per trovare l'ID istanza di un processo, usare il Get-Job cmdlet .

Tipo:Guid[]
Posizione:0
Valore predefinito:All instances
Necessario:True
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-Job

Specifica il processo per il quale vengono recuperati i risultati.

Immettere una variabile contenente il processo o un comando che lo ottiene. È anche possibile inviare tramite pipe un oggetto processo a Receive-Job.

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

-Keep

Indica che questo cmdlet salva i dati aggregati del flusso nel sistema, anche dopo averli ricevuti. Per impostazione predefinita, i dati del flusso aggregato vengono cancellati dopo la visualizzazione con Receive-Job.

La chiusura della sessione o la rimozione del processo con il Remove-Job cmdlet elimina anche i dati aggregati del flusso.

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

-Location

Specifica una matrice di posizioni. Questo cmdlet ottiene solo i risultati dei processi nelle posizioni specificate.

Tipo:String[]
Posizione:1
Valore predefinito:All locations
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-Name

Specifica una matrice di nomi descrittivi. Questo cmdlet ottiene i risultati dei processi con i nomi specificati. I carattere jolly sono supportati.

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

-NoRecurse

Indica che questo cmdlet ottiene risultati solo dal processo specificato. Per impostazione predefinita, Receive-Job ottiene anche i risultati di tutti i processi figlio del processo specificato.

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

-Session

Specifica una matrice di sessioni. Questo cmdlet ottiene i risultati dei processi eseguiti nella sessione di PowerShell specificata (PSSession). Immettere una variabile che contiene la sessione PSSession o un comando che ottiene la sessione PSSession, ad esempio un Get-PSSession comando.

Tipo:PSSession[]
Posizione:1
Valore predefinito:All sessions
Necessario:False
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-Wait

Indica che questo cmdlet elimina il prompt dei comandi fino a quando non vengono ricevuti tutti i risultati del processo. Per impostazione predefinita, Receive-Job restituisce immediatamente i risultati disponibili.

Per impostazione predefinita, il parametro Wait attende fino a quando il processo non si trova in uno degli stati seguenti:

  • Completato
  • Non riuscito
  • Arrestato
  • Suspended
  • Disconnesso

Per indirizzare il parametro Wait per continuare ad attendere se lo stato del processo è Suspended o Disconnected, usare il parametro Force insieme al parametro Wait.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

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

-WriteEvents

Indica che questo cmdlet segnala le modifiche apportate allo stato del processo mentre attende il completamento del processo.

Questo parametro è valido solo quando il parametro Wait viene usato nel comando e il parametro Keep viene omesso.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

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

-WriteJobInResults

Indica che questo cmdlet restituisce l'oggetto processo seguito dai risultati.

Questo parametro è valido solo quando il parametro Wait viene usato nel comando e il parametro Keep viene omesso.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

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

Input

Job

È possibile inviare tramite pipe oggetti processo a questo cmdlet.

Output

PSObject

Questo cmdlet restituisce i risultati dei comandi nel processo.

Note

PowerShell include gli alias seguenti per Receive-Job:

  • Tutte le piattaforme:
    • rcjb