> ## Documentation Index
> Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt
> Use this file to discover all available pages before exploring further.

# XTaskQueueRegisterWaiter

> XTaskQueueRegisterWaiter

# XTaskQueueRegisterWaiter

Registra um identificador de espera em uma fila de tarefas.

## Sintaxe

```cpp theme={null}
HRESULT XTaskQueueRegisterWaiter(  
         XTaskQueueHandle queue,  
         XTaskQueuePort port,  
         HANDLE waitHandle,  
         void* callbackContext,  
         XTaskQueueCallback* callback,  
         XTaskQueueRegistrationToken* token  
)  
```

### Parâmetros

*queue*   \_In\_\
Tipo: XTaskQueueHandle

A fila para a qual enviar o retorno de chamada.

*port*   \_In\_\
Tipo: [XTaskQueuePort](/pt-BR/reference/system/xtaskqueue/enums/xtaskqueueport)

A porta para a qual enviar o retorno de chamada. Os retornos de chamada podem ser atribuídos a portas de trabalho ou de conclusão.

*waitHandle*   \_In\_\
Tipo: HANDLE

O identificador a ser monitorado.

<Note>Este é o identificador de espera que, quando sinalizado, fará com que o retorno de chamada seja invocado. O identificador de espera normalmente é um evento de redefinição automática ou manual. Se o identificador de espera for de redefinição manual, o retorno de chamada será invocado repetidamente enquanto o evento estiver sinalizado. Se não for isso que você deseja, redefina o evento dentro do retorno de chamada ou cancele o registro do retorno de chamada de espera.</Note>

*callbackContext*   \_In\_opt\_\
Tipo: void\*

Um ponteiro de contexto opcional que será passado para o retorno de chamada.

*callback*   \_In\_\
Tipo: [XTaskQueueCallback\*](/pt-BR/reference/system/xtaskqueue/functions/xtaskqueuecallback)

Um ponteiro para a função de retorno de chamada.

*token*   \_Out\_\
Tipo: [XTaskQueueRegistrationToken\*](/pt-BR/reference/system/xtaskqueue/structs/xtaskqueueregistrationtoken)

Um token de registro. Ele pode ser passado para [XTaskQueueUnregisterWaiter](/pt-BR/reference/system/xtaskqueue/functions/xtaskqueueunregisterwaiter) para cancelar o registro da espera.

### Valor retornado

Tipo: HRESULT

Código de sucesso ou de erro HRESULT.

## Comentários

<Note>Não é seguro chamar esta função em um thread sensível ao tempo. Para obter mais informações, consulte [Threads sensíveis ao tempo](https://learn.microsoft.com/gaming/gdk/docs/gdk-dev/console-dev/overviews/threads/time-sensitive-threads).</Note>

Quando o identificador de espera é satisfeito, a fila de tarefas invoca o retorno de chamada especificado. Isso oferece uma maneira eficiente de adicionar itens a uma fila de tarefas em resposta à sinalização de identificadores.

O exemplo a seguir registra um identificador de kernel Win32 em uma fila de tarefas. Seu retorno de chamada será enviado para a fila quando o identificador for sinalizado. Normalmente, você criaria um evento de redefinição automática para usar na sinalização. Se o identificador não for de redefinição automática, um novo retorno de chamada será enviado quando o retorno de chamada atual for concluído, enquanto o identificador permanecer sinalizado.

```cpp theme={null}
void CreatingTaskQueueWaiter()
{
    HANDLE waitEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
    if (waitEvent == nullptr)
    {
        printf("Error creating wait handle: %d\r\n", GetLastError());
        return;
    }

    XTaskQueueHandle queue;

    HRESULT hr = XTaskQueueCreate(
        XTaskQueueDispatchMode::ThreadPool,
        XTaskQueueDispatchMode::ThreadPool, 
        &queue);

    if (FAILED(hr))
    {
        printf("Error creating task queue: %x\n", hr);
        CloseHandle(waitEvent);
        return;
    }

    auto callback = [](void*, bool)
    {
        printf("Callback invoked.\r\n");
    };

    XTaskQueueRegistrationToken token;

    hr = XTaskQueueRegisterWaiter(
        queue, 
        XTaskQueuePort::Completion, 
        waitEvent, 
        nullptr, 
        callback, 
        &token);

    if (FAILED(hr))
    {
        printf("Error registering task queue waiter: %x\n", hr);
        CloseHandle(waitEvent);
        XTaskQueueCloseHandle(queue);
        return;
    }

    // Now, whenever our wait event becomes signaled the callback will be called.
    for (uint32_t i = 0; i < 5; i++)
    {
        SetEvent(waitEvent);
        Sleep(100);
    }

    // Note: unregistering the waiter is optional
    XTaskQueueUnregisterWaiter(queue, token);
    XTaskQueueCloseHandle(queue);
    CloseHandle(waitEvent);
}
```

## Requisitos

**Cabeçalho:** XTaskQueue.h

**Biblioteca:** xgameruntime.lib

**Plataformas compatíveis:** Windows, consoles da família XBOX One e consoles XBOX Series

## Documentação conceitual

* [Visão geral da biblioteca XTaskQueue](/pt-BR/build/core-features/common/async/async-libraries/async-library-xtaskqueue)
* [Threads sensíveis ao tempo](https://learn.microsoft.com/gaming/gdk/docs/gdk-dev/console-dev/overviews/threads/time-sensitive-threads)

## Confira também

[Membros de XTaskQueue](/pt-BR/reference/system/xtaskqueue/xtaskqueue_members)\
[Modelo de programação assíncrona](/pt-BR/build/core-features/common/async/async-programming-model)\
[Design da fila de tarefas assíncrona](/pt-BR/build/core-features/common/async/async-task-queue-design)


## Related topics

- [XTaskQueueRegisterWaiter](/reference/system/xtaskqueue/functions/xtaskqueueregisterwaiter.md)
- [XTaskQueueUnregisterWaiter](/reference/system/xtaskqueue/functions/xtaskqueueunregisterwaiter.md)