Get-Job

Get-Job [-Command <string[]>] [<CommonParameters>]

Get-Job [[-InstanceId] <Guid[]>] [<CommonParameters>]

Get-Job [[-Name] <string[]>] [<CommonParameters>]

Get-Job [[-Id] <Int32[]>] [<CommonParameters>]

Get-Job [-State {<NotStarted> | <Running> | <Completed> | <Failed> | <Stopped> | <Blocked>}] [<CommonParameters>]

C:\PS>get-job

Beschreibung
-----------
Mit diesem Befehl werden alle Hintergrundaufträge in der aktuellen Sitzung abgerufen. Aufträge, die in anderen Sitzungen erstellt wurden, werden auch dann nicht berücksichtigt, wenn sie auf dem lokalen Computer ausgeführt werden.

C:\PS>$j = get-job -name Job1

C:\PS> $ID = $j.InstanceID

C:\PS> $ID

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

C:\PS> stop-job -instanceid $ID

Beschreibung
-----------
Diese Befehle zeigen, wie die Instanz-ID eines Auftrags abgerufen und zum Beenden eines Auftrags verwendet werden kann. Instanz-IDs sind im Gegensatz zu Auftragsnamen eindeutig.

Im ersten Befehl wird mit dem Cmdlet "Get-Job" ein Auftrag abgerufen. Der Auftrag wird anhand des Name-Parameters identifiziert. Das Auftragsobjekt, das von Get-Job zurückgegeben wird, wird vom Befehl in der Variablen "$j" gespeichert. Dieses Beispiel enthält nur einen Auftrag mit dem angegebenen Namen.

Mit dem zweiten Befehl wird die InstanceId-Eigenschaft des Objekts in der Variablen "$j" abgerufen und in der Variablen "$ID" gespeichert. 

Der dritte Befehl zeigt den Wert der Variablen "$ID" an.

Im vierten Befehl der Auftrag mit dem Cmdlet "Stop-Job" beendet. Mit dem InstanceId-Parameter wird der Auftrag identifiziert, und mit der Variablen "$ID" wird die Instanz-ID des Auftrags dargestellt.

C:\PS>get-job -command "*get-process*"

Beschreibung
-----------
Mit diesem Befehl werden die Aufträge im System mit dem Befehl "Get-Process" abgerufen. Die abgerufenen Aufträge werden mit dem Command-Parameter von Get-Job beschränkt. Aufträge, die einen Get-Process-Befehl in der Befehlszeichenfolge enthalten, werden vom Befehl mit Platzhalterzeichen (*) abgerufen.

C:\PS>"*get-process*" | get-job

Beschreibung
-----------
Analog zum Befehl im vorherigen Beispiel werden von diesem Befehl die Aufträge im System abgerufen, die einen Get-Process-Befehl enthalten. Der Befehl sendet eine Zeichenfolge (in doppelten Anführungszeichen) mit einem Pipelineoperator (|) an das Cmdlet "Get-Job". Dies entspricht dem vorherigen Befehl.

C:\PS>get-job -state NotStarted

Beschreibung
-----------
Mit diesem Befehl werden nur die Aufträge abgerufen, die erstellt, jedoch noch nicht gestartet wurden. Dazu gehören auch Aufträge, deren Ausführung in der Zukunft geplant ist, sowie Aufträge, deren Ausführung noch nicht geplant ist.

C:\PS>get-job -name job*

Beschreibung
-----------
Mit diesem Befehl werden alle Aufträge abgerufen, deren Name mit "job" beginnt. "job<Nummer>" ist der Standardname für einen Auftrag. Daher werden mit diesem Befehl alle Aufträge abgerufen, denen kein expliziter Name zugewiesen wurde.

C:\PS>start-job -scriptblock {get-process} -name MyJob

C:\PS> $j = get-job -name MyJob

C:\PS> $j

Id       Name      State      HasMoreData     Location    Command
--       ----      -----      -----------     --------    -------
1        myjob     Completed  True            localhost   get-process

C:\PS> 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
...

Beschreibung
-----------
In diesem Beispiel wird gezeigt, wie mit Get-Job ein Auftragsobjekt abgerufen und wie der Auftrag mit dem Auftragsobjekt in einem Befehl dargestellt wird.

Im ersten Befehl wird ein Hintergrundauftrag, der auf dem lokalen Computer den Befehl "Get-Process" ausführt, mit dem Cmdlet "Start-Job" gestartet. Mit dem Name-Parameter von Start-Job wird dem Auftrag im Befehl ein Anzeigename zugewiesen.

Im zweiten Befehl wird der Auftrag mit Get-Job abgerufen. Der Auftrag wird anhand des Name-Parameters von Get-Job identifiziert. Mit dem Befehl wird das resultierende Auftragsobjekt in der Variablen "$j" gespeichert.

Im dritten Befehl wird der Wert des Auftragsobjekts in der Variablen "$j" angezeigt. Der Wert der State-Eigenschaft zeigt an, dass der Auftrag abgeschlossen wurde. Der Wert der HasMoreData-Eigenschaft zeigt an, dass noch nicht alle Ergebnisse des Auftrags abgerufen wurden.

Im vierten Befehl wird das Cmdlet "Receive-Job" verwendet, um die Ergebnisse des Auftrags abzurufen. Dabei wird der Auftrag mit dem Auftragsobjekt in der Variablen "$j" dargestellt. Sie können Auftragsobjekte auch mit einem Pipelineoperator an Receive-Job senden.

C:\PS>start-job -scriptblock {get-eventlog system}

C:\PS> invoke-command -computername S1 -scriptblock {get-eventlog system} -AsJob

C:\PS> invoke-command -computername S2 -scriptblock {start-job -scriptblock {get-eventlog system}}

C:\PS> get-job

Id    Name     State      HasMoreData   Location   Command
--    ----     -----      -----------   --------   -------
1     Job1     Running    True          localhost  get-eventlog system
2     Job2     Running    True          S1         get-eventlog system

C:\PS> invoke-command -computername S2 -scriptblock {get-job}

Id    Name     State      HasMoreData   Location   Command
--    ----     -----      -----------   --------   -------
4     Job4     Running    True          localhost  get-eventlog system

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

Im ersten Befehl wird mit dem Cmdlet "Start-Job" ein Auftrag auf dem lokalen Computer gestartet.

Im zweiten Befehl wird mit dem AsJob-Parameter von Invoke-Command ein Auftrag auf dem Computer "S1" gestartet. Obwohl die Befehle im Auftrag auf dem Remotecomputer ausgeführt werden, wird das Auftragsobjekt auf dem lokalen Computer erstellt. Der Auftrag wird daher mit lokalen Befehlen verwaltet.

Im dritten Befehl wird ein Start-Job-Befehl mit dem Cmdlet "Invoke-Command" auf dem Computer "S2" ausgeführt. Bei dieser Methode wird das Auftragsobjekt auf dem Remotecomputer erstellt. Der Auftrag wird daher mit Remotebefehlen verwaltet.

Mit dem vierten Befehl werden die Aufträge auf dem lokalen Computer mit Get-Job abgerufen.

Im fünften Befehl wird mit Invoke-Command ein Get-Job-Befehl auf dem Computer "S2" ausgeführt.

In der Beispielausgabe werden die Ergebnisse der Get-Job-Befehle angezeigt.

Weitere Informationen über das Ausführen von Hintergrundaufträgen auf Remotecomputern finden Sie unter "about_Remote_Jobs".

C:\PS>start-job -scriptblock {get-process}

Id       Name            State      HasMoreData     Location             Command
--       ----            -----      -----------     --------             -------
1        Job1            Failed     False           localhost            get-process

C:\PS> (get-job).jobstateinfo | format-list -property *

State  : Failed
Reason :


C:\PS> get-job | format-list *

HasMoreData   : False
StatusMessage :
Location      : localhost
Command       : get-process
JobStateInfo  : Failed
Finished      : System.Threading.ManualResetEvent
InstanceId    : fb792295-1318-4f5d-8ac8-8a89c5261507
Id            : 1
Name          : Job1
ChildJobs     : {Job2}
Output        : {}
Error         : {}
Progress      : {}
Verbose       : {}
Debug         : {}
Warning       : {}
StateChanged  :


C:\PS> (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.

Beschreibung
-----------
Mit diesem Befehl wird veranschaulicht, wie Ursachen von Auftragsfehlern mit dem Auftragsobjekt untersucht werden können, das von Get-Job zurückgegeben wird. Außerdem wird gezeigt, wie untergeordnete Aufträge des jeweiligen Auftrags abgerufen werden können.

Im ersten Befehl wird mit dem Cmdlet "Start-Job" ein Auftrag auf dem lokalen Computer gestartet. Das Auftragsobjekt, das von Start-Job zurückgegeben wird, weist auf einen Auftragsfehler hin. Der Wert der State-Eigenschaft lautet "Failed".

Im zweiten Befehl wird das Auftragsobjekt mit Get-Job abgerufen. Im Befehl wird der Wert der JobStateInfo-Eigenschaft des Objekts mit der DOT-Methode abgerufen. Das Objekt in der JobStateInfo-Eigenschaft wird mit einem Pipelineoperator an das Cmdlet "Format-List" gesendet, mit dem alle Eigenschaften des Objekts (*) in einer Liste formatiert werden.

Das Ergebnis des Befehls "Format-List" zeigt, dass der Wert der Reason-Eigenschaft für den Auftrag leer ist.

Mit dem dritten Befehl werden weitere Untersuchungen durchgeführt. Mit dem Befehl "Get-Job" wird der Auftrag abgerufen, und mit einem Pipelineoperator wird das gesamte Auftragsobjekt an das Cmdlet "Format-List" gesendet, das alle Eigenschaften des Auftrags in einer Liste anzeigt.

Die Anzeige aller Eigenschaften im Auftragsobjekt zeigt, dass der Auftrag den untergeordneten Auftrag "Job2" enthält.

Im vierten Befehl wird das Auftragsobjekt für den untergeordneten Auftrag "Job2" mit Get-Job abgerufen. Dies ist der Auftrag, in dem der Befehl tatsächlich ausgeführt wurde. Mit der DOT-Eigenschaft wird dabei die Reason-Eigenschaft für die JobStateInfo-Eigenschaft abgerufen.

Das Ergebnis zeigt, dass der Auftrag aufgrund des Fehlers "Zugriff verweigert" nicht ordnungsgemäß ausgeführt werden konnte. In diesem Fall hatte der Benutzer vergessen, beim Öffnen von Windows PowerShell die Option "Als Administrator ausführen" zu verwenden. 

Da Hintergrundaufträge die Remotefeatures von Windows PowerShell verwenden, muss der Computer für Remoting konfiguriert sein, um einen Auftrag ausführen zu können; dies gilt auch, wenn der Auftrag auf dem lokalen Computer ausgeführt wird.

Informationen über die Anforderungen für Remoting in Windows PowerShell finden Sie unter "about_Remote_Requirements". Informationen zur Problembehandlung erhalten Sie unter "about_Remote_Troubleshooting".