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

Descripción
-----------
Este comando obtiene todos los trabajos en segundo plano iniciados en la sesión actual. No incluye trabajos creados en otras sesiones, aunque los trabajos se ejecuten en el equipo 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

Descripción
-----------
Estos comandos muestran la forma de obtener el identificador de instancia de un trabajo y usarlo a continuación para detenerlo. A diferencia del nombre de un trabajo, que no es único, el identificador de instancia es único.

El primer comando utiliza el cmdlet Get-Job para obtener un trabajo. Utiliza el parámetro Name para identificar el trabajo. El comando almacena el objeto de trabajo que Get-Job devuelve en la variable $j. En este ejemplo, solo hay un trabajo con el nombre especificado.

El segundo comando obtiene la propiedad InstanceId del objeto de la variable $j y lo almacena en la variable $ID. 

El tercer comando muestra el valor de la variable $ID.

El cuarto comando utiliza el cmdlet Stop-Job para detener el trabajo. Utiliza el parámetro InstanceId para identificar el trabajo y la variable $ID para representar el identificador de instancia del trabajo.

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

Descripción
-----------
Este comando obtiene los trabajos del sistema que incluyen un comando Get-Process. Utiliza el parámetro Command de Get-Job para limitar los trabajos recuperados. Además, utiliza caracteres comodín (*) para obtener trabajos que incluyen un comando Get-Process en cualquier lugar de la cadena de comando.

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

Descripción
-----------
Al igual que el comando del ejemplo anterior, este comando obtiene los trabajos del sistema que incluyen un comando Get-Process. El comando utiliza un operador de canalización (|) para enviar una cadena (entre comillas dobles) al cmdlet Get-Job. Es el equivalente del comando anterior.

C:\PS>get-job -state NotStarted

Descripción
-----------
Este comando obtiene solamente los trabajos que se han creado pero no se han iniciado todavía. Estos trabajos son los programados para ejecutarse en el futuro y los que no están programados todavía.

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

Descripción
-----------
Este comando obtiene todos los trabajos cuyos nombres comienzan por "job". Dado que "job<número>" es el nombre predeterminado de un trabajo, este comando obtiene todos los trabajos a los que no se ha asignado un nombre explícitamente.

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

Descripción
-----------
En este ejemplo se muestra la forma de utilizar Get-Job para obtener un objeto de trabajo y usarlo a continuación para representar el trabajo en un comando.

El primer comando utiliza el cmdlet Start-Job para iniciar un trabajo en segundo plano que ejecuta un comando Get-Process en el equipo local. El comando utiliza el parámetro Name de Start-Job para asignar un nombre simple al trabajo.

El segundo comando usa Get-Job para obtener el trabajo. Utiliza el parámetro Name de Get-Job para identificar el trabajo. El comando guarda el objeto de trabajo resultante en la variable $j.

El tercer comando muestra el valor del objeto de trabajo en la variable $j. El valor de la propiedad State muestra que el trabajo se ha completado. El valor de la propiedad HasMoreData muestra que hay resultados disponibles del trabajo que no se han recuperado todavía.

El cuarto comando utiliza el cmdlet Receive-Job para obtener los resultados del trabajo. Utiliza el objeto de trabajo en la variable $j para representar el trabajo. También se puede utilizar un operador de canalización para enviar un objeto de trabajo a 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

Descripción
-----------
En este ejemplo se muestra que el cmdlet Get-Job puede obtener todos los trabajos que se iniciaron en la sesión actual, aunque se hayan iniciado utilizando métodos diferentes.

El primer comando utiliza el cmdlet Start-Job para iniciar un trabajo en el equipo local.

El segundo comando usa el parámetro AsJob de Invoke-Command para iniciar un trabajo en el equipo S1. Aunque los comandos del trabajo se ejecutan en el equipo remoto, el objeto de trabajo se crea en el equipo local, por lo que se han de utilizar comandos locales para administrar el trabajo.

El tercer comando usa el cmdlet Invoke-Command para ejecutar un comando Start-Job en el equipo S2. Con este método, el objeto de trabajo se crea en el equipo remoto, por lo que se han de utilizar comandos remotos para administrar el trabajo.

El cuarto comando utiliza Get-Job para obtener los trabajos almacenados en el equipo local.

El quinto comando utiliza Invoke-Command para ejecutar un comando Get-Job en el equipo S2.

En el resultado de ejemplo se muestran los resultados de los comandos Get-Job.

Para obtener más información sobre cómo se ejecutan trabajos en segundo plano en equipos remotos, vea 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.

Descripción
-----------
Este comando muestra la forma de utilizar el objeto de trabajo que Get-Job devuelve para investigar por qué se produjo un error en un trabajo. También muestra la forma de obtener los trabajos secundarios de cada trabajo.

El primer comando utiliza el cmdlet Start-Job para iniciar un trabajo en el equipo local. El objeto de trabajo que Start-Job devuelve muestra que se produjo un error en el trabajo. El valor de la propiedad State es "Failed".

El segundo comando usa Get-Job para obtener el objeto de trabajo. El comando utiliza el método de puntos para obtener el valor de la propiedad JobStateInfo del objeto. Utiliza un operador de canalización para enviar el objeto en la propiedad JobStateInfo al cmdlet Format-List, que aplica formato a todas las propiedades del objeto (*) en una lista.

El resultado del comando Format-List muestra que el valor de la propiedad Reason del trabajo está en blanco.

El tercer comando investiga más detalles. Utiliza un comando Get-Job para obtener el trabajo y, a continuación, utiliza un operador de canalización para enviar el objeto de trabajo completo al cmdlet Format-List, que muestra todas las propiedades del trabajo en una lista.

La presentación de todas las propiedades en el objeto de trabajo muestra que el trabajo contiene un trabajo secundario denominado "Job2".

El cuarto comando utiliza Get-Job para obtener el objeto de trabajo que representa el trabajo secundario Job2. Este es el trabajo en el que el comando se ejecuta realmente. Utiliza el método de puntos para obtener la propiedad Reason de la propiedad JobStateInfo.

El resultado muestra que se produjo un error en el trabajo debido a un error de tipo "acceso denegado". En este caso, el usuario se olvidó de utilizar la opción "Ejecutar como administrador" al abrir Windows PowerShell. 

Dado que los trabajos en segundo plano utilizan las características de comunicación remota de Windows PowerShell, el equipo debe estar configurado para la comunicación remota al ejecutar un trabajo, aunque el trabajo se ejecute en el equipo local.

Para obtener información sobre los requisitos para la comunicación remota en Windows PowerShell, vea about_Remote_Requirements. Para obtener sugerencias de solución de problemas, vea about_Remote_Troubleshooting.