Unterdrückt die Eingabeaufforderung, bis ein oder alle Windows PowerShell-Hintergrundaufträge abgeschlossen sind, die in der Sitzung... (Wait-Job)

   

NAME
Wait-Job

# ÜBERSICHT
Unterdrückt die Eingabeaufforderung, bis ein oder alle Windows PowerShell-Hintergrundaufträge abgeschlossen sind, die in der Sitzung ausgeführt werden.

# SYNTAX
Wait-Job [[-InstanceId] <Guid[]>] [-Any] [-Timeout <int>] [<CommonParameters>]

Wait-Job [-Job] <Job[]> [-Any] [-Timeout <int>] [<CommonParameters>]

Wait-Job [[-Name] <string[]>] [-Any] [-Timeout <int>] [<CommonParameters>]

Wait-Job [-Id] <Int32[]> [-Any] [-Timeout <int>] [<CommonParameters>]

Wait-Job [-State {NotStarted | Running | Completed | Failed | Stopped | Blocked}] [-Any] [-Timeout <int>] [<CommonParameters>]

# BESCHREIBUNG
Das Cmdlet "Wait-Job" wartet, bis Windows PowerShell-Hintergrundaufträge abgeschlossen sind, bevor die Eingabeaufforderung angezeigt wird. Sie können warten, bis ein Hintergrundauftrag abgeschlossen wurde oder bis alle Hintergrundaufträge abgeschlossen wurden, und Sie können eine maximale Wartezeit für den Auftrag festlegen.

Mit Wait-Job können Sie Hintergrundaufträge abrufen, die mit Start-Job oder mit dem AsJob-Parameter von Invoke-Command gestartet wurden.

Wenn die Befehle im Auftrag abgeschlossen sind, wird die Eingabeaufforderung von Wait-Job angezeigt, und ein Auftragsobjekt wird zurückgegeben, das über die Pipeline an einen anderen Befehl übergeben werden kann.

# PARAMETER
-Any [<SwitchParameter>]
Zeigt die Eingabeaufforderung an (und gibt das Auftragsobjekt zurück), wenn ein Auftrag abgeschlossen wird. Standardmäßig wird mit Wait-Job die Eingabeaufforderung erst angezeigt, wenn alle angegebenen Aufträge abgeschlossen sind.

Erforderlich? false
Position? named
Standardwert
Pipelineeingaben akzeptieren?false
Platzhalterzeichen akzeptieren?false

-Id <Int32[]>
Wartet auf Aufträge mit den angegebenen IDs.

Die ID ist eine ganze Zahl, die den Auftrag in der aktuellen Sitzung eindeutig identifiziert. Sie lässt sich leichter merken und eingeben als die InstanceId, ist jedoch nur in der aktuellen Sitzung eindeutig. Sie können eine oder mehrere IDs eingeben (durch Trennzeichen getrennt). Um die ID eines Auftrags zu suchen, geben Sie "Get-Job" ohne Parameter ein.

Erforderlich? true
Position? 1
Standardwert
Pipelineeingaben akzeptieren?true (ByPropertyName)
Platzhalterzeichen akzeptieren?false

-InstanceId <Guid[]>
Wartet auf Aufträge mit den angegebenen Instanz-IDs. Standardmäßig sind dies alle Aufträge.

Eine Instanz-ID ist ein GUID, der den Auftrag auf dem Computer eindeutig identifiziert. Um die Instanz-ID eines Auftrags zu suchen, verwenden Sie Get-Job.

Erforderlich? false
Position? 1
Standardwert
Pipelineeingaben akzeptieren?true (ByPropertyName)
Platzhalterzeichen akzeptieren?false

-Job <Job[]>
Wartet auf die angegebenen Aufträge. Geben Sie eine Variable ein, die die Auftragsobjekte enthält, oder einen Befehl, mit dem die Auftragsobjekte abgerufen werden. Sie können Auftragsobjekte auch mit einem Pipelineoperator an das Cmdlet "Wait-Job" senden. Standardmäßig wartet Wait-Job auf alle in der aktuellen Sitzung erstellten Aufträge.

Erforderlich? true
Position? 1
Standardwert
Pipelineeingaben akzeptieren?true (ByValue, ByPropertyName)
Platzhalterzeichen akzeptieren?false

-Name <string[]>
Wartet auf Aufträge mit dem angegebenen Anzeigenamen.

Erforderlich? false
Position? 1
Standardwert
Pipelineeingaben akzeptieren?true (ByPropertyName)
Platzhalterzeichen akzeptieren?false

-State <JobState>
Wartet auf Aufträge im angegebenen Status. Gültige Werte sind "NotStarted", "Running", "Completed", "Stopped", "Failed" und "Blocked".

Erforderlich? false
Position? named
Standardwert
Pipelineeingaben akzeptieren?true (ByPropertyName)
Platzhalterzeichen akzeptieren?false

-Timeout <int>
Bestimmt die maximale Wartezeit in Sekunden für jeden Hintergrundauftrag. Mit dem Standardwert -1 wird bis zum Abschluss des Auftrags gewartet, unabhängig von der Ausführungsdauer des Auftrags. Die Zeitsteuerung wird beim Senden des Befehls "Wait-Job" und nicht beim Senden des Befehls "Start-Job" gestartet.

Nach Ablauf dieser Zeitspanne endet die Wartezeit, und die Eingabeaufforderung wird beendet, auch wenn der Auftrag noch ausgeführt wird. Es wird keine Fehlermeldung angezeigt.

Erforderlich? false
Position? named
Standardwert
Pipelineeingaben akzeptieren?false
Platzhalterzeichen akzeptieren?false

<CommonParameters>
Dieses Cmdlet unterstützt folgende allgemeine Parameter: "Verbose", "Debug",
"ErrorAction", "ErrorVariable", "WarningAction", "WarningVariable",
"OutBuffer" und "OutVariable". Weitere Informationen
erhalten Sie mit dem Befehl "get-help about_commonparameters".

# EINGABEN
System.Management.Automation.RemotingJob
Sie können ein Auftragsobjekt über die Pipeline an Wait-Job übergeben.

# AUSGABEN
System.Management.Automation.RemotingJob
Wait-Job gibt die Auftragsobjekte zurück, die die abgeschlossenen Aufträge darstellen. Wenn der Wartevorgang aufgrund einer Überschreitung des Timeout-Parameterwerts beendet wird, werden von Wait-Job keine Objekte zurückgegeben.

# HINWEISE

# BEISPIEL 1

C:\PS>get-job | wait-job

Beschreibung
-----------
Dieser Befehl wartet, bis die Ausführung aller Hintergrundaufträge in der Sitzung abgeschlossen wurde.

# BEISPIEL 2

C:\PS>$s = new-pssession server01, server02, server03

C:\PS> invoke-command -session $s -scriptblock {start-job -name Date1 -scriptblock {get-date}}

C:\PS> $done = invoke-command -session $s -command {wait-job -name Date1}

C:\PS> $done.count
3

Beschreibung
-----------
In diesem Beispiel wird gezeigt, wie das Cmdlet "Wait-Job" unter Verwendung des Cmdlet "Start-Job" mit Aufträgen verwendet wird, die auf Remotecomputern gestartet wurden. Der Befehl "Start-Job" und der Befehl "Wait-Job" werden mit dem Cmdlet "Invoke-Command" an den Remotecomputer gesendet.

In diesem Beispiel wird mit Wait-Job bestimmt, ob der Befehl "Get-Date", der als Hintergrundauftrag auf drei verschiedenen Computern ausgeführt wird, abgeschlossen wurde.

Im ersten Befehl wird eine Windows PowerShell-Sitzung (PSSession) auf jedem der drei Remotecomputer erstellt und in der Variablen "$s" gespeichert.

Im zweiten Befehl wird mit dem Cmdlet "Invoke-Command" ein Start-Job-Befehl in jeder der drei Sitzungen in $s ausgeführt. Alle Aufträge erhalten den Namen "Date1".

Im dritten Befehl wird mit dem Cmdlet "Invoke-Command" ein Wait-Job-Befehl ausgeführt. Dieser Befehl wartet, bis die Ausführung der Date1-Aufträge auf den einzelnen Computern abgeschlossen ist. Die resultierende Auflistung (Array) von Auftragsobjekten wird in der Variablen "$done" gespeichert.

Im vierten Befehl wird mit der Count-Eigenschaft des Arrays von Auftragsobjekten in der Variablen "$done" bestimmt, wie viele Aufträge abgeschlossen wurden.

# BEISPIEL 3

C:\PS>$s = new-pssession (get-content machines.txt)

C:\PS> $c = 'get-eventlog -log system | where {$_.EntryType -eq "error" -and $_.Source -eq "LSASRV"} | out-file errors.txt'

C:\PS> invoke-command -session $s -scriptblock {param($c)start-job -scriptblock {$c}} -ArgumentList $c

C:\PS> invoke-command -session $s -scriptblock {wait-job -any}

Beschreibung
-----------
In diesem Beispiel wird mit dem Any-Parameter von Wait-Job bestimmt, wann der erste einer Reihe von Hintergrundaufträgen abgeschlossen ist, die in der aktuellen Sitzung ausgeführt werden. Außerdem wird gezeigt, wie mit dem Cmdlet "Wait-Job" auf den Abschluss von Remoteaufträgen gewartet wird.

Im ersten Befehl wird auf allen Computern, die in der Datei "Machines.txt" aufgeführt sind, eine PSSession erstellt und in der Variablen "$s" gespeichert. Der Befehl ruft mit dem Cmdlet "Get-Content" den Inhalt der Datei ab. Der Befehl "Get-Content" wird in Klammern eingeschlossen, um sicherzustellen, dass er vor dem Befehl "New-PSSession" ausgeführt wird.

Im zweiten Befehl wird eine Get-EventLog-Befehlszeichenfolge (in Anführungszeichen) in der Variablen "$c" gespeichert.

Im dritten Befehl wird der Befehl "Start-Job" in den einzelnen Sitzungen in $s mit dem Cmdlet "Invoke-Command" ausgeführt. Mit dem Befehl "Start-Job" wird ein Hintergrundauftrag gestartet, der den Befehl in $c ausführt.

Da es sich bei $c um eine Variable auf dem lokalen Computer handelt, verwendet der Befehl das param-Schlüsselwort zur Deklaration der lokalen Variablen im Befehl und den ArgumentList-Parameter zur Angabe der Werte für diese Variablen.

Im vierten Befehl wird ein Wait-Job-Befehl in den Sitzungen mit dem Cmdlet "Invoke-Command" ausgeführt. Mit dem Cmdlet "Wait-Job" wird gewartet, bis der erste Auftrag auf den Remotecomputern abgeschlossen ist.

# BEISPIEL 4

C:\PS>$s = new-pssession Server01, Server02, Server03

C:\PS> $jobs = invoke-command -session $s -scriptblock {start-job -script {get-date}}

C:\PS> $done = invoke-command -session $s -scriptblock {wait-job -timeout 30}

Beschreibung
-----------
In diesem Beispiel wird gezeigt, wie mit dem Timeout-Parameter von Wait-Job eine maximale Wartezeit für Aufträge festgelegt wird, die auf Remotecomputern ausgeführt werden.

Im ersten Befehl wird eine PSSession auf jedem der drei Remotecomputer "Server01", "Server02" und "Server03" erstellt, und die PSSessions werden in der Variablen "$s" gespeichert.

Im zweiten Befehl wird der Befehl "Start-Job" in den einzelnen PSSessions in $s mit dem Cmdlet "Invoke-Command" ausgeführt. Die resultierenden Auftragsobjekte werden in der Variablen "$jobs" gespeichert.

Im dritten Befehl wird der Befehl "Wait-Job" in den einzelnen PSSessions in $s mit dem Cmdlet "Invoke-Command" ausgeführt. Mit dem Befehl "Wait-Job" wird bestimmt, ob alle Befehle innerhalb von 30 Sekunden abgeschlossen wurden. Der Befehl verwendet den Timeout-Parameter mit dem Wert 30 (Sekunden), um die maximale Wartezeit festzulegen und speichert die Ergebnisse des Befehls in der Variablen "$done".

In diesem Fall wurde nach 30 Sekunden nur der Befehl auf dem Computer "Server02" abgeschlossen. Wait-Job beendet den Wartevorgang, zeigt die Eingabeaufforderung an und gibt das Objekt zurück, das den abgeschlossenen Auftrag darstellt.

Die Variable "$done" enthält ein Auftragsobjekt, das den Auftrag darstellt, der auf Server02 ausgeführt wurde.

# BEISPIEL 5

C:\PS>wait-job -id 1,2,5 -any

Beschreibung
-----------
Mit diesem Befehl werden drei Aufträge anhand der IDs identifiziert, und es wird gewartet, bis einer der Aufträge abgeschlossen wurde. Die Eingabeaufforderung wird zurückgegeben, wenn der erste Auftrag abgeschlossen wird.

# BEISPIEL 6

C:\PS>wait-job -name DailyLog -timeout 120

Beschreibung
-----------
Dieser Befehl wartet 120 Sekunden (zwei Minuten) auf den Abschluss des Auftrags "DailyLog". Wenn der Auftrag in den folgenden zwei Minuten nicht abgeschlossen wird, wird die Eingabeaufforderung dennoch zurückgegeben, und der Auftrag wird weiterhin im Hintergrund ausgeführt.

# BEISPIEL 7

C:\PS>wait-job -name Job3

Beschreibung
-----------
Mit diesem Wait-Job-Befehl wird der Auftrag, auf den gewartet werden soll, anhand des Namens identifiziert.

# BEISPIEL 8

C:\PS>C:\PS> $j = start-job -script {get-childitem *.ps1| where {$_lastwritetime -gt ((get-date) - (new-timespan -days 7))}}

C:\PS> $j | wait-job

Beschreibung
-----------
In diesem Beispiel wird gezeigt, wie das Cmdlet "Wait-Job" unter Verwendung des Cmdlet "Start-Job" mit Aufträgen verwendet wird, die dem lokalen Computer gestartet wurden.

Mit diesen Befehlen wird ein Auftrag gestartet, um die Windows PowerShell-Skriptdateien abzurufen, die in der vergangenen Woche hinzugefügt oder aktualisiert wurden.

Im ersten Befehl wird mit dem Cmdlet "Start-Job" ein Hintergrundauftrag auf dem lokalen Computer gestartet. Im Auftrag wird ein Get-ChildItem-Befehl ausgeführt, mit dem alle Dateien mit der Dateinamenerweiterung ".ps1" abgerufen werden, die in der vergangenen Woche hinzugefügt oder aktualisiert wurden.

Im dritten Befehl wird mit dem Cmdlet "Wait-Job" gewartet, bis der Auftrag abgeschlossen wurde. Wenn der Auftrag abgeschlossen wird, wird das Auftragsobjekt vom Befehl angezeigt, das Informationen über den Auftrag enthält.

# BEISPIEL 9

C:\PS>$s = new-pssession Server01, Server02, Server03

C:\PS> $j = invoke-command -session $s -scriptblock {get-process} -asjob

C:\PS> $j | wait-job

Beschreibung
-----------
In diesem Beispiel wird gezeigt, wie mit dem AsJob-Parameter des Cmdlet "Invoke-Command" das Cmdlet "Wait-Job" mit Aufträgen verwendet wird, die auf Remotecomputern gestartet wurden. Mit AsJob wird der Auftrag auf dem lokalen Computer erstellt, und die Ergebnisse werden automatisch an den lokalen Computer zurückgegeben, obwohl der Auftrag auf den Remotecomputern ausgeführt wird.

In diesem Beispiel wird mit Wait-Job bestimmt, ob die Ausführung des Befehls "Get-Process" in den Sitzungen auf drei Remotecomputern abgeschlossen wurde.

Im ersten Befehl werden PSSessions auf drei Computern erstellt und in der Variablen "$s" gespeichert.

Im zweiten Befehl wird mit dem Cmdlet "Invoke-Command" ein Get-Process-Befehl in jeder der drei PSSession in $s ausgeführt. Bei dem Befehl wird der Befehl asynchron mit dem AsJob-Parameter als Hintergrundauftrag ausgeführt. Analog zu den Aufträgen, die mit Start-Job gestartet wurden, wird vom Befehl ein Auftragsobjekt zurückgegeben, und das Objekt wird in der Variablen "$j" gespeichert.

Im dritten Befehl wird das Auftragsobjekt in $j mit einem Pipelineoperator (|) an das Cmdlet "Wait-Job" gesendet. In diesem Fall ist der Befehl "Invoke-Command" nicht erforderlich, da sich der Auftrag auf dem lokalen Computer befindet.

-------------------------- BEISPIEL 10 --------------------------

C:\PS>get-job

Id Name State HasMoreData Location Command
-- ---- ----- ----------- -------- -------
1 Job1 Completed True localhost,server01.. get-service
4 Job4 Completed True localhost dir | where

C:\PS> wait-job -id 1

Beschreibung
-----------
Dieser Befehl wartet auf den Auftrag mit dem ID-Wert 1.

VERWANDTE LINKS
Online version: http://go.microsoft.com/fwlink/?LinkID=113422 (möglicherweise auf Englisch)
about_Jobs
about_Job_Details
about_Remote_Jobs
Start-Job
Get-Job
Receive-Job
Stop-Job
Remove-Job
Invoke-Command

C:\Windows>powershell get-help Remove-Job -full

ColorConsole [Version 1.7.1000] PowerShell 2.0-Export
Microsoft Windows [Version 6.1.7600]
Copyright (c) 2014 Microsoft Corporation.

OS: Windows 10, 8.1, 8, 7, Vista / Windows Server 2016, 2012, 2008
»»»» ColorConsole





... Home  
... Impressum
... ColorConsole

... CMD
... Netsh-XP
... Netsh-7
... Netsh-Vista
... Powershell










Windows 10 download: Starter, Home (Basic Premium), Professional und Win 10 Ultimate!

... facebook.de
HTTP: ... PS_Windows/de/Wait-Job.htm
0.14

Standard Schriftarten für Programme zurücksetzen bei Windows 7, aber wie?

 /

Mouse pointer shadow in Windows 10, (enable, disable)?

 /

Der Unterschied zwischen Favoriten und Quick-Links?

 /

In Windows 10 ein bestimmtes Update eentfernen, aber wie?

 /