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

Descrição
-----------
Esse comando obtém todos os trabalhos em segundo plano iniciados na sessão atual. Não inclui trabalhos criados em outras sessões, mesmo se os trabalhos forem executados no computador local.

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

Descrição
-----------
Esses comandos mostram como obter a ID de instância de um trabalho e usá-la para parar um trabalho. Ao contrário do que ocorre com o nome de um trabalho, que não é exclusivo, a ID de instância é exclusiva.

O primeiro comando utiliza o cmdlet Get-Job para obter um trabalho. Ele usa o parâmetro Name para identificar o trabalho. O comando armazena o objeto de trabalho que Get-Job retorna na variável $j. Nesse exemplo, há somente um trabalho com o nome especificado.

O segundo comando obtém a propriedade InstanceId do objeto na variável $j e a armazena na variável $ID. 

O terceiro comando exibe o valor da variável $ID.

O quarto comando utiliza o cmdlet Stop-Job para parar o trabalho. Ele usa o parâmetro InstanceId para identificar o trabalho e a variável $ID para representar a ID de instância do trabalho.

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

Descrição
-----------
Esse comando obtém os trabalhos no sistema que incluem um comando Get-Process. O comando usa o parâmetro Command de Get-Job para limitar os trabalhos recuperados. O comando usa caracteres curinga (*) para obter trabalhos que incluem um comando Get-Process em qualquer lugar da cadeia de caracteres de comando.

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

Descrição
-----------
Como o comando no exemplo anterior, esse comando obtém os trabalhos no sistema que incluem um comando Get-Process. O comando usa um operador de pipeline (|) para enviar uma cadeia de caracteres (entre aspas duplas) para o cmdlet Get-Job. Equivale ao comando anterior.

C:\PS>get-job -state NotStarted

Descrição
-----------
Esse comando obtém apenas os trabalhos que foram criados, mas que ainda não foram iniciados. Isso inclui trabalhos que estão agendados para execução no futuro e os que ainda não estão agendados.

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

Descrição
-----------
Esse comando obtém todos os trabalhos que têm nomes de trabalho começando com "job". Como "job<número>" é o nome padrão de um trabalho, esse comando obtém todos os trabalhos que não têm um nome explicitamente atribuído.

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

Descrição
-----------
Esse exemplo mostra como usar Get-Job para obter um objeto de trabalho e, em seguida, mostra como usar o objeto de trabalho para representar o trabalho em um comando.

O primeiro comando usa o cmdlet Start-Job para iniciar um trabalho em segundo plano que executa um comando Get-Process no computador local. O comando usa o parâmetro Name de Start-Job para atribuir um nome amigável ao trabalho.

O segundo comando utiliza Get-Job para obter o trabalho. Ele usa o parâmetro Name de Get-Job de modo a identificar o trabalho. O comando salva o objeto de trabalho resultante na variável $j.

O terceiro comando exibe o valor do objeto de trabalho na variável $j. O valor da propriedade State mostra que o trabalho está concluído. O valor da propriedade HasMoreData mostra que existem resultados disponíveis do trabalho que ainda não foram recuperados.

O quarto comando utiliza o cmdlet Receive-Job para obter os resultados do trabalho. Ele usa o objeto de trabalho na variável $j para representar o trabalho. Você também pode usar um operador de pipeline para enviar um objeto de trabalho para Receive-Job.

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

Descrição
-----------
Esse exemplo demonstra que o cmdlet Get-Job pode obter todos os trabalhos que foram iniciados na sessão atual, mesmo que eles tenham sido iniciados com o uso de métodos diferentes.

O primeiro comando usa o cmdlet Start-Job para iniciar um trabalho no computador local.

O segundo comando usa o parâmetro AsJob de Invoke-Command para iniciar um trabalho no computador S1. Embora os comandos no trabalho sejam executados no computador remoto, o objeto de trabalho é criado no computador local, de modo que você usará comandos locais para gerenciar o trabalho.

O terceiro comando usa o cmdlet Invoke-Command para executar um comando Start-Job no computador S2. Com esse método, o objeto de trabalho é criado no computador remoto, de modo que você usará comandos remotos para gerenciar o trabalho.

O quarto comando usa Get-Job para obter os trabalhos armazenados no computador local.

O quinto comando usa Invoke-Command para executar um comando Get-Job no computador S2.

A saída de exemplo mostra os resultados dos comandos Get-Job.

Para obter mais informações sobre como executar trabalhos em segundo plano em computadores remotos, consulte 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.

Descrição
-----------
Esse comando mostra como usar o objeto de trabalho que Get-Job retorna para investigar por que um trabalho falhou. Ele também mostra como obter os trabalhos filhos de cada trabalho.

O primeiro comando usa o cmdlet Start-Job para iniciar um trabalho no computador local. O objeto de trabalho que Start-Job retorna mostra que o trabalho falhou. O valor da propriedade State é "Falha".

O segundo comando utiliza Get-Job para obter o objeto de trabalho. O comando usa o método de ponto para obter o valor da propriedade JobStateInfo do objeto. Ele usa um operador de pipeline para enviar o objeto na propriedade JobStateInfo para o cmdlet Format-List, que formata todas as propriedades do objeto (*) em uma lista.

O resultado do comando Format-List mostra que o valor da propriedade Reason do trabalho está vazio.

O terceiro comando investiga mais além. Ele usa um comando Get-Job para obter o trabalho e usa um operador de pipeline para enviar o objeto de trabalho inteiro para o cmdlet Format-List, que exibe todas as propriedades do trabalho em uma lista.

A exibição de todas as propriedades no objeto de trabalho mostra que o trabalho contém um trabalho filho denominado "Job2".

O quarto comando usa Get-Job para obter o objeto de trabalho que representa o trabalho filho Job2. Esse é o trabalho no qual o comando foi, de fato, executado. Ele usa o método de ponto para obter a propriedade Reason da propriedade JobStateInfo.

O resultado mostra que o trabalho falhou por causa de um erro de "acesso negado". Nesse caso, o usuário esqueceu de usar a opção "Executar como administrador" ao abrir o Windows PowerShell. 

Como trabalhos em segundo plano usam os recursos de comunicação remota do Windows PowerShell, a comunicação remota deve ser configurada no computador para a execução de um trabalho, mesmo quando o trabalho for executado no computador local.

Para obter informações sobre requisitos de comunicação remota no Windows PowerShell, consulte about_Remote_Requirements. Para obter dicas de solução de problemas, consulte about_Remote_Troubleshooting.