Get-Job

Get-Job
    [[-Id] <Int32[]>]
    [-IncludeChildJob]
    [-ChildJobState <JobState>]
    [-HasMoreData <Boolean>]
    [-Before <DateTime>]
    [-After <DateTime>]
    [-Newest <Int32>]
    [<CommonParameters>]

Get-Job
    [-State] <JobState>
    [-IncludeChildJob]
    [-ChildJobState <JobState>]
    [-HasMoreData <Boolean>]
    [-Before <DateTime>]
    [-After <DateTime>]
    [-Newest <Int32>]
    [<CommonParameters>]

Get-Job
    [-IncludeChildJob]
    [-ChildJobState <JobState>]
    [-HasMoreData <Boolean>]
    [-Before <DateTime>]
    [-After <DateTime>]
    [-Newest <Int32>]
    [-Command <String[]>]
    [<CommonParameters>]

Get-Job
    [-InstanceId] <Guid[]>
    [-IncludeChildJob]
    [-ChildJobState <JobState>]
    [-HasMoreData <Boolean>]
    [-Before <DateTime>]
    [-After <DateTime>]
    [-Newest <Int32>]
    [<CommonParameters>]

Get-Job
    [-Name] <String[]>
    [-IncludeChildJob]
    [-ChildJobState <JobState>]
    [-HasMoreData <Boolean>]
    [-Before <DateTime>]
    [-After <DateTime>]
    [-Newest <Int32>]
    [<CommonParameters>]

Get-Job
    [-Filter] <Hashtable>
    [<CommonParameters>]

L’applet de commande Get-Job obtient des objets qui représentent les travaux en arrière-plan qui ont été démarrés dans la session active. Vous pouvez utiliser Get-Job pour obtenir des travaux qui ont été démarrés à l’aide de l’applet de commande Start-Job, ou à l’aide du paramètre AsJob de n’importe quelle applet de commande.

Sans paramètres, une commande Get-Job obtient tous les travaux de la session active. Vous pouvez utiliser les paramètres de Get-Job pour obtenir des travaux particuliers.

L’objet de travail qui l' Get-Job retourne contient des informations utiles sur le travail, mais il ne contient pas les résultats du travail. Pour obtenir les résultats, utilisez l’applet de commande Receive-Job.

Un travail en arrière-plan Windows PowerShell est une commande qui s’exécute en arrière-plan sans interagir avec la session active. En règle générale, vous utilisez un travail en arrière-plan pour exécuter une commande complexe qui prend beaucoup de temps. Pour plus d’informations sur les travaux en arrière-plan dans Windows PowerShell, consultez about_Jobs.

À compter de Windows PowerShell 3.0, l’applet de commande Get-Job obtient également des types de travaux personnalisés, tels que des travaux de flux de travail et des instances de travaux planifiés. Pour rechercher le type de travail d’un travail, utilisez la propriété PSJobTypeName de la tâche.

Pour activer Get-Job pour obtenir un type de travail personnalisé, importez le module qui prend en charge le type de travail personnalisé dans la session avant d’exécuter une commande Get-Job, soit à l’aide de l’applet de commande Import-Module, soit en utilisant ou en obtenant une applet de commande dans le module. Pour plus d’informations sur un type de travail personnalisé particulier, consultez la documentation de la fonctionnalité de type de travail personnalisé.

PS C:\> Get-Job

Cette commande obtient tous les travaux en arrière-plan démarrés dans la session active. Il n’inclut pas les travaux créés dans d’autres sessions, même si les travaux s’exécutent sur l’ordinateur local.

The first command uses the **Get-Job** cmdlet to get a job. It uses the *Name* parameter to identify the job. The command stores the job object that **Get-Job** returns in the $j variable. In this example, there is only one job with the specified name.
PS C:\> $j = Get-Job -Name Job1

The second command gets the **InstanceId** property of the object in the $j variable and stores it in the $ID variable.
PS C:\> $ID = $j.InstanceID

The third command displays the value of the $ID variable.
PS C:\> $ID

Guid
----
03c3232e-1d23-453b-a6f4-ed73c9e29d55

The fourth command uses Stop-Job cmdlet to stop the job. It uses the *InstanceId* parameter to identify the job and $ID variable to represent the instance ID of the job.
PS C:\> Stop-Job -InstanceId $ID

Ces commandes montrent comment obtenir l’ID d’instance d’un travail, puis l’utiliser pour arrêter un travail. Contrairement au nom d’un travail, qui n’est pas unique, l’ID d’instance est unique.

PS C:\> Get-Job -Command "*get-process*"

Cette commande obtient les travaux sur le système qui incluent une commande Get-Process. La commande utilise le paramètre Command de get-job pour limiter les travaux récupérés. La commande utilise des caractères génériques (*) pour obtenir des travaux qui incluent une commande Get-Process n’importe où dans la chaîne de commande.

PS C:\> "*get-process*" | Get-Job

Comme la commande dans l’exemple précédent, cette commande obtient les travaux sur le système qui incluent une commande Get-Process . La commande utilise un opérateur de pipeline (|) pour envoyer une chaîne, entre guillemets, à l’applet de commande Get-Job . Il s’agit de l’équivalent de la commande précédente.

PS C:\> Get-Job -State NotStarted

Cette commande obtient uniquement les travaux qui ont été créés, mais qui n’ont pas encore été démarrés. Cela inclut les travaux qui sont planifiés pour s’exécuter à l’avenir et ceux qui ne sont pas encore planifiés.

PS C:\> Get-Job -Name Job*

Cette commande obtient tous les travaux qui ont des noms de travaux qui commencent par le travail. Étant donné que<nombre> est le nom par défaut d’un travail, cette commande obtient tous les travaux qui n’ont pas de nom attribué explicitement.

The first command uses the **Start-Job** cmdlet to start a background job that runs a **Get-Process** command on the local computer. The command uses the *Name* parameter of **Start-Job** to assign a friendly name to the job.
PS C:\> Start-Job -ScriptBlock {Get-Process} -Name MyJob

The second command uses Get-Job to get the job. It uses the *Name* parameter of **Get-Job** to identify the job. The command saves the resulting job object in the $j variable.
PS C:\> $j = Get-Job -Name MyJob

The third command displays the value of the job object in the $j variable. The value of the **State** property shows that the job is completed. The value of the **HasMoreData** property shows that there are results available from the job that have not yet been retrieved.
PS C:\> $j
Id     Name            PSJobTypeName   State         HasMoreData     Location             Command
--     ----            -------------   -----         -----------     --------             -------
6      MyJob           BackgroundJob   Completed     True            localhost            Get-Process

The fourth command uses the **Receive-Job** cmdlet to get the results of the job. It uses the job object in the $j variable to represent the job. You can also use a pipeline operator to send a job object to **Receive-Job**.
PS C:\> Receive-Job -Job $j
Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----      ----- -----   ------     -- -----------
    124       4    13572      12080    59            1140 audiodg
    783      16    11428      13636   100             548 CcmExec
     96       4     4252       3764    59            3856 ccmsetup
...

Cet exemple montre comment utiliser Get-Job pour obtenir un objet de travail, puis comment utiliser l’objet de travail pour représenter le travail dans une commande.

The first command uses the **Start-Job** cmdlet to start a job on the local computer.
PS C:\> Start-Job -ScriptBlock {Get-EventLog System}

The second command uses the *AsJob* parameter of the **Invoke-Command** cmdlet to start a job on the S1 computer. Even though the commands in the job run on the remote computer, the job object is created on the local computer, so you use local commands to manage the job.
PS C:\> Invoke-Command -ComputerName S1 -ScriptBlock {Get-EventLog System} -AsJob

The third command uses the **Invoke-Command** cmdlet to run a **Start-Job** command on the S2 computer. By using this method, the job object is created on the remote computer, so you use remote commands to manage the job.
PS C:\> Invoke-Command -ComputerName S2 -ScriptBlock {Start-Job -ScriptBlock {Get-EventLog System}}

The fourth command uses **Get-Job** to get the jobs stored on the local computer. The **PSJobTypeName** property of jobs, introduced in Windows PowerShell 3.0, shows that the local job started by using the **Start-Job** cmdlet is a background job and the job started in a remote session by using the **Invoke-Command** cmdlet is a remote job.
PS C:\> Get-Job
Id     Name       PSJobTypeName   State         HasMoreData     Location        Command
--     ----       -------------   -----         -----------     --------        -------
1      Job1       BackgroundJob   Running       True            localhost       Get-EventLog System
2      Job2       RemoteJob       Running       True            S1              Get-EventLog System

The fifth command uses **Invoke-Command** to run a **Get-Job** command on the S2 computer.The sample output shows the results of the Get-Job command. On the S2 computer, the job appears to be a local job. The computer name is localhost and the job type is a background job.For more information about how to run background jobs on remote computers, see about_Remote_Jobs.
PS C:\> Invoke-Command -ComputerName S2 -ScriptBlock {Start-Job -ScriptBlock {Get-EventLog System}}
Id    Name     PSJobTypeName  State      HasMoreData   Location   Command
--    ----     -------------  -----      -----------   -------    -------
4     Job4     BackgroundJob  Running    True          localhost  Get-Eventlog System

Cet exemple montre que l’applet de commande Get-Job peut obtenir tous les travaux démarrés dans la session active, même s’ils ont été démarrés à l’aide de différentes méthodes.

The first command uses the **Start-Job** cmdlet to start a job on the local computer. The job object that **Start-Job** returns shows that the job failed. The value of the **State** property is Failed.
PS C:\> Start-Job -ScriptBlock {Get-Process}
Id     Name       PSJobTypeName   State       HasMoreData     Location             Command
--     ----       -------------   -----       -----------     --------             -------
1      Job1       BackgroundJob   Failed      False           localhost            Get-Process

The second command uses the **Get-Job** cmdlet to get the job. The command uses the dot method to get the value of the **JobStateInfo** property of the object. It uses a pipeline operator to send the object in the **JobStateInfo** property to the Format-List cmdlet, which formats all of the properties of the object (*) in a list.The result of the **Format-List** command shows that the value of the **Reason** property of the job is blank.
PS C:\> (Get-Job).JobStateInfo | Format-List -Property *
State  : Failed
Reason :

The third command investigates more. It uses a **Get-Job** command to get the job and then uses a pipeline operator to send the whole job object to the **Format-List** cmdlet, which displays all of the properties of the job in a list.The display of all properties in the job object shows that the job contains a child job named Job2.
PS C:\> Get-Job | Format-List -Property *
HasMoreData   : False
StatusMessage :
Location      : localhost
Command       : get-process
JobStateInfo  : Failed
Finished      : System.Threading.ManualReset
EventInstanceId    : fb792295-1318-4f5d-8ac8-8a89c5261507
Id            : 1
Name          : Job1
ChildJobs     : {Job2}
Output        : {}
Error         : {}
Progress      : {}
Verbose       : {}
Debug         : {}
Warning       : {}
StateChanged  :

The fourth command uses **Get-Job** to get the job object that represents the Job2 child job. This is the job in which the command actually ran. It uses the dot method to get the **Reason** property of the **JobStateInfo** property.The result shows that the job failed because of an Access Denied error. In this case, the user forgot to use the Run as administrator option when starting Windows PowerShell.Because background jobs use the remoting features of Windows PowerShell, the computer must be configured for remoting to run a job, even when the job runs on the local computer.For information about requirements for remoting in Windows PowerShell, see about_Remote_Requirements. For troubleshooting tips, see about_Remote_Troubleshooting.
PS C:\> (Get-Job -Name job2).JobStateInfo.Reason
Connecting to remote server using WSManCreateShellEx api failed. The async callback gave the following error message: Access is denied.

Cette commande montre comment utiliser l’objet de travail qui get-job retourne pour déterminer pourquoi un travail a échoué. Il montre également comment obtenir les emplois enfants de chaque travail.

The first command uses the **Workflow** keyword to create the WFProcess workflow.
PS C:\> Workflow WFProcess {Get-Process}

The second command uses the *AsJob* parameter of the WFProcess workflow to run the workflow as a background job. It uses the *JobName* parameter of the workflow to specify a name for the job, and the *PSPrivateMetadata* parameter of the workflow to specify a custom ID.
PS C:\> WFProcess -AsJob -JobName WFProcessJob -PSPrivateMetadata @{MyCustomId = 92107}

The third command uses the *Filter* parameter of **Get-Job** to get the job by custom ID that was specified in the *PSPrivateMetadata* parameter.
PS C:\> Get-Job -Filter @{MyCustomId = 92107}
Id     Name            State         HasMoreData     Location             Command
--     ----            -----         -----------     --------             -------
1      WFProcessJob    Completed     True            localhost            WFProcess

Cet exemple montre comment utiliser le paramètre Filter pour obtenir un travail de flux de travail. Le paramètre Filter, introduit dans Windows PowerShell 3.0, est valide uniquement sur les types de travaux personnalisés, tels que les travaux de flux de travail et les travaux planifiés.

The first command gets the jobs in the current session. The output includes a background job, a remote job and several instances of a scheduled job. The remote job, Job4, appears to have failed.
PS C:\> Get-Job
Id     Name            PSJobTypeName   State         HasMoreData     Location             Command
--     ----            -------------   -----         -----------     --------             -------
2      Job2            BackgroundJob   Completed     True            localhost            .\Get-Archive.ps1
4      Job4            RemoteJob       Failed        True            Server01, Server02   .\Get-Archive.ps1
7      UpdateHelpJob   PSScheduledJob  Completed     True            localhost            Update-Help
8      UpdateHelpJob   PSScheduledJob  Completed     True            localhost            Update-Help
9      UpdateHelpJob   PSScheduledJob  Completed     True            localhost            Update-Help
10     UpdateHelpJob   PSScheduledJob  Completed     True            localhost            Update-Help

The second command uses the *IncludeChildJob* parameter of **Get-Job**. The output adds the child jobs of all jobs that have child jobs.In this case, the revised output shows that only the Job5 child job of Job4 failed.
PS C:\> Get-Job -IncludeChildJob
Id     Name            PSJobTypeName   State         HasMoreData     Location             Command
--     ----            -------------   -----         -----------     --------             -------
2      Job2            BackgroundJob   Completed     True            localhost           .\Get-Archive.ps1
3      Job3                            Completed     True            localhost           .\Get-Archive.ps1
4      Job4            RemoteJob       Failed        True            Server01, Server02  .\Get-Archive.ps1
5      Job5                            Failed        False           Server01            .\Get-Archive.ps1
6      Job6                            Completed     True            Server02            .\Get-Archive.ps1
7      UpdateHelpJob   PSScheduledJob  Completed     True            localhost            Update-Help
8      UpdateHelpJob   PSScheduledJob  Completed     True            localhost            Update-Help
9      UpdateHelpJob   PSScheduledJob  Completed     True            localhost            Update-Help
10     UpdateHelpJob   PSScheduledJob  Completed     True            localhost            Update-Help

The third command uses the *ChildJobState* parameter with a value of Failed.The output includes all parent jobs and only the child jobs that failed.
PS C:\> Get-Job -Name Job4 -ChildJobState Failed
Id     Name            PSJobTypeName   State         HasMoreData     Location             Command
--     ----            -------------   -----         -----------     --------             -------
2      Job2            BackgroundJob   Completed     True            localhost           .\Get-Archive.ps1
4      Job4            RemoteJob       Failed        True            Server01, Server02  .\Get-Archive.ps1
5      Job5                            Failed        False           Server01            .\Get-Archive.ps1
7      UpdateHelpJob   PSScheduledJob  Completed     True            localhost            Update-Help
8      UpdateHelpJob   PSScheduledJob  Completed     True            localhost            Update-Help
9      UpdateHelpJob   PSScheduledJob  Completed     True            localhost            Update-Help
10     UpdateHelpJob   PSScheduledJob  Completed     True            localhost            Update-Help

The fifth command uses the **JobStateInfo** property of jobs and its **Reason** property to discover why Job5 failed.
PS C:\> (Get-Job -Name Job5).JobStateInfo.Reason
Connecting to remote server Server01 failed with the following error message:
Access is denied.
For more information, see the about_Remote_Troubleshooting Help topic.

Cet exemple montre l’effet de l’utilisation des paramètres IncludeChildJob et ChildJobState de l’applet de commande Get-Job .

Cette applet de commande prend en charge les paramètres courants : -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutBuffer, -OutVariable, -PipelineVariable, -ProgressAction, -Verbose, -WarningAction et -WarningVariable. Pour plus d’informations, consultez about_CommonParameters.

Vous ne pouvez pas diriger d'entrée vers cette applet de commande.

Cette applet de commande retourne des objets qui représentent les travaux dans la session.

• La propriété PSJobTypeName des travaux indique le type de travail du travail. La valeur de propriété est déterminée par l’auteur du type de travail. La liste suivante présente les types de travaux courants.

  • backgroundJob. Travail local démarré à l’aide de start-job .

  • RemoteJob . Travail démarré dans un psSession à l’aide du paramètre AsJob de l’applet de commande Invoke-Command.

  • PSWorkflowJob. Travail démarré à l’aide de l'AsJob paramètre commun de flux de travail.