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>]

Das Cmdlet Get-Job ruft Objekte ab, die die Hintergrundaufträge darstellen, die in der aktuellen Sitzung gestartet wurden. Sie können Get-Job verwenden, um Aufträge abzurufen, die mit dem Cmdlet Start-Job oder mit dem AsJob-Parameter eines beliebigen Cmdlets gestartet wurden.

Ohne Parameter ruft ein Get-Job-Befehl alle Aufträge in der aktuellen Sitzung ab. Sie können die Parameter von Get-Job verwenden, um bestimmte Aufträge abzurufen.

Das Auftragsobjekt, das Get-Job zurückgibt, enthält nützliche Informationen über den Auftrag, aber nicht die Auftragsergebnisse. Verwenden Sie zum Abrufen der Ergebnisse das Cmdlet Receive-Job.

Ein Windows PowerShell-Hintergrundauftrag ist ein Befehl, der im Hintergrund ausgeführt wird, ohne mit der aktuellen Sitzung zu interagieren. In der Regel verwenden Sie einen Hintergrundauftrag, um einen komplexen Befehl auszuführen, der lange dauert. Weitere Informationen zu Hintergrundaufträgen in Windows PowerShell finden Sie unter about_Jobs.

Ab Windows PowerShell 3.0 ruft das Cmdlet Get-Job auch benutzerdefinierte Auftragstypen ab, z. B. Workflowaufträge und Instanzen geplanter Aufträge. Um den Auftragstyp eines Auftrags zu finden, verwenden Sie die PSJobTypeName Eigenschaft des Auftrags.

Um Get-Job zum Abrufen eines benutzerdefinierten Auftragstyps zu aktivieren, importieren Sie das Modul, das den benutzerdefinierten Auftragstyp unterstützt, in die Sitzung, bevor Sie einen Get-Job-Befehl ausführen, entweder mithilfe des Cmdlets Import-Module oder durch Verwenden oder Abrufen eines Cmdlets im Modul. Informationen zu einem bestimmten benutzerdefinierten Auftragstyp finden Sie in der Dokumentation des Features für den benutzerdefinierten Auftragstyp.

PS C:\> Get-Job

Dieser Befehl ruft alle Hintergrundaufträge ab, die in der aktuellen Sitzung gestartet werden. Sie enthält keine Aufträge, die in anderen Sitzungen erstellt wurden, auch wenn die Aufträge auf dem lokalen Computer ausgeführt werden.

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

Diese Befehle zeigen, wie Sie die Instanz-ID eines Auftrags abrufen und dann verwenden, um einen Auftrag zu beenden. Im Gegensatz zum Namen eines Auftrags, der nicht eindeutig ist, ist die Instanz-ID eindeutig.

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

Mit diesem Befehl werden die Aufträge auf dem System abgerufen, die einen Get-Process Befehl enthalten. Der Befehl verwendet den Command-Parameter von Get-Job, um die abgerufenen Aufträge einzuschränken. Der Befehl verwendet Platzhalterzeichen (*), um Aufträge abzurufen, die einen Get-Process-Befehl an einer beliebigen Stelle in der Befehlszeichenfolge enthalten.

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

Wie der Befehl im vorherigen Beispiel ruft dieser Befehl die Aufträge auf dem System ab, die einen Get-Process-Befehl enthalten. Der Befehl verwendet einen Pipelineoperator (|), um eine Zeichenfolge in Anführungszeichen an das Cmdlet Get-Job zu senden. Es entspricht dem vorherigen Befehl.

PS C:\> Get-Job -State NotStarted

Dieser Befehl ruft nur die Aufträge ab, die erstellt wurden, aber noch nicht gestartet wurden. Dazu gehören Aufträge, die in Zukunft ausgeführt werden sollen und die noch nicht geplant sind.

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

Dieser Befehl ruft alle Aufträge ab, die über Auftragsnamen verfügen, die mit dem Auftrag beginnen. Da es sich bei der Auftragsnummer<> um den Standardnamen für einen Auftrag handelt, ruft dieser Befehl alle Aufträge ab, denen kein explizit zugewiesener Name zugewiesen wurde.

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

In diesem Beispiel wird gezeigt, wie Get-Job zum Abrufen eines Auftragsobjekts verwendet wird, und dann wird gezeigt, wie das Auftragsobjekt verwendet wird, um den Auftrag in einem Befehl darzustellen.

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

In diesem Beispiel wird veranschaulicht, dass mit dem Cmdlet "Get-Job" alle Aufträge abgerufen werden können, die in der aktuellen Sitzung gestartet wurden, auch wenn sie mit unterschiedlichen Methoden gestartet wurden.

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.

Dieser Befehl zeigt, wie das Auftragsobjekt, das Get-Job zurückgibt, verwendet wird, um zu untersuchen, warum ein Auftrag fehlgeschlagen ist. Außerdem wird gezeigt, wie sie die Kinderaufträge jeder Aufgabe erhalten.

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

In diesem Beispiel wird gezeigt, wie Sie den parameter Filter verwenden, um einen Workflowauftrag abzurufen. Der in Windows PowerShell 3.0 eingeführte parameter Filter ist nur für benutzerdefinierte Auftragstypen gültig, z. B. Workflowaufträge und geplante Aufträge.

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.

In diesem Beispiel wird gezeigt, wie sich die Verwendung der Parameter IncludeChildJob und ChildJobState des Cmdlets Get-Job auswirkt.

Dieses Cmdlet unterstützt die allgemeinen Parameter -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutBuffer, -OutVariable, -PipelineVariable, -ProgressAction, -Verbose, -WarningAction und -WarningVariable. Weitere Informationen findest du unter about_CommonParameters.

Eingaben können nicht an dieses Cmdlet weitergereicht werden.

Dieses Cmdlet gibt Objekte zurück, die die Aufträge in der Sitzung darstellen.

• Die PSJobTypeName Eigenschaft von Aufträgen gibt den Auftragstyp des Auftrags an. Der Eigenschaftswert wird vom Autor des Auftragstyps bestimmt. In der folgenden Liste sind allgemeine Auftragstypen aufgeführt.

  • HintergrundJob. Lokaler Auftrag, der mit Start-Job gestartet wurde.

  • RemoteJob. Der Auftrag wurde in einer PSSession mithilfe des Parameters AsJob des Cmdlets Invoke-Command gestartet.

  • PSWorkflowJob. Auftrag, der mit der Verwendung des AsJob allgemeinen Parameter von Workflows gestartet wurde.