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

# XTaskQueueSubmitDelayedCallback

> XTaskQueueSubmitDelayedCallback

# XTaskQueueSubmitDelayedCallback

Envía una devolución de llamada a la cola para el puerto especificado.

## Sintaxis

```cpp theme={null}
HRESULT XTaskQueueSubmitDelayedCallback(  
         XTaskQueueHandle queue,  
         XTaskQueuePort port,  
         uint32_t delayMs,  
         void* callbackContext,  
         XTaskQueueCallback* callback  
)  
```

### Parámetros

*queue*   \_In\_\
Tipo: XTaskQueueHandle

La cola a la que se enviará la devolución de llamada.

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

El puerto al que se enviará la devolución de llamada. Las devoluciones de llamada se pueden asignar a los puertos de trabajo o de finalización.

*delayMs*   \_In\_\
Tipo: uint32\_t

El número de milisegundos de retraso antes de enviar la devolución de llamada a la cola.

<Note>Se puede enviar una devolución de llamada para que se agregue a la cola en algún momento futuro. Si *delayMs* es distinto de cero, la devolución de llamada se colocará en una lista de pendientes y se inicializará un temporizador con el tiempo de espera más próximo. Cuando transcurra ese tiempo, la devolución de llamada con el siguiente tiempo se colocará en la lista de ejecución. La cola generará una [XTaskQueueMonitorCallback](/reference/system/xtaskqueue/functions/xtaskqueuemonitorcallback) y, si la cola se ejecuta en un modo de distribución de grupo de subprocesos, se enviará trabajo al grupo de subprocesos.</Note>

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

Un puntero de contexto opcional que se pasará a la devolución de llamada.

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

Un puntero a la función de devolución de llamada.

### Valor devuelto

Tipo: HRESULT

Código de error o de éxito HRESULT.

## Comentarios

Esta devolución de llamada se agregará a la cola después de *delayMs* milisegundos.

<img src="https://mintcdn.com/microsoft-4404708b/gzrdvT5kpqAXKEQt/images/gdk/reference/note.gif?s=6c1a4c009b25ad5315c45ce51bc83983" alt="alerta" width="10" height="10" data-path="images/gdk/reference/note.gif" /> **Nota de rendimiento:**\
Agregar un elemento a una cola debe ser una operación sin bloqueos ni esperas para satisfacer los requisitos de rendimiento del código de niveles superiores. Las siguientes API no usan bloqueos:

* [XTaskQueueSubmitCallback](/reference/system/xtaskqueue/functions/xtaskqueuesubmitcallback)
* [XTaskQueueSubmitDelayedCallback](/reference/system/xtaskqueue/functions/xtaskqueuesubmitdelayedcallback)
* [XTaskQueueDispatch](/reference/system/xtaskqueue/functions/xtaskqueuedispatch), siempre que se pase 0 para *timeoutInMs*

En el ejemplo siguiente se permite enviar devoluciones de llamada en el futuro mediante la función **XTaskQueueSubmitDelayedCallback**. Esta es una excelente manera de reintentar una llamada con error después de un breve retraso; también se puede usar como un temporizador económico para eventos periódicos.

<Note>**SubmitCallback** es una función auxiliar que se define en el ejemplo de código de la función [XTaskQueueSubmitCallback](/reference/system/xtaskqueue/functions/xtaskqueuesubmitcallback).</Note>

```cpp theme={null}
void SubmittingDelayedCallback()
{
    XTaskQueueHandle queue;

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

    if (FAILED(hr))
    {
        printf("failed to create task queue: 0x%x\r\n", hr);
        return;
    }

    struct CallContext
    {
        DWORD count;
        XTaskQueueHandle queue;
        XTaskQueueCallback* callback;
    } callContext;

    auto callback = [](void* context, bool cancel)
    {
        CallContext *callContext = static_cast<CallContext*>(context);
        callContext->count++;
        printf("Periodic callback %d\r\n", callContext->count);
        if (callContext->count != 10 && !cancel)
        {
            HRESULT hr = XTaskQueueSubmitDelayedCallback(
                callContext->queue, 
                XTaskQueuePort::Completion, 
                500, 
                callContext, 
                callContext->callback);

            if (FAILED(hr))
            {
                printf("Failed submitting next callback: 0x%x\r\n", hr);
                callContext->count = 10; // Prevent us from waiting forever.
            }
        }
    };

    callContext.count = 0;
    callContext.queue = queue;
    callContext.callback = callback;

    // Use the task queue to make 10 periodic calls
    hr = XTaskQueueSubmitDelayedCallback(
        queue,
        XTaskQueuePort::Completion,
        500,
        &callContext,
        callback);

    if (FAILED(hr))
    {
        printf("Failed submitting delayed callback: 0x%x\r\n", hr);
        XTaskQueueCloseHandle(queue);
        return;
    }

    // Now wait for all the calls to complete.
    while (callContext.count != 10)
    {
        Sleep(1000);
    }

    XTaskQueueTerminate(queue, true, nullptr, nullptr);
    XTaskQueueCloseHandle(queue);
}
```

## Requisitos

**Encabezado:** XTaskQueue.h

**Biblioteca:** xgameruntime.lib

**Plataformas compatibles:** Windows, consolas de la familia XBOX One y consolas XBOX Series

## Consulte también

[Miembros de XTaskQueue](/reference/system/xtaskqueue/xtaskqueue_members)\
[Modelo de programación asincrónica](/build/core-features/common/async/async-programming-model)\
[Diseño de la cola de tareas asincrónicas](/build/core-features/common/async/async-task-queue-design)