Compartir a través de

Usar un temporizador para enviar un elemento de trabajo

Las APIs importantes

Aprenda a crear un elemento de trabajo que se ejecute después de que transcurre un temporizador.

Creación de un temporizador de un solo disparo

Use el método createTimer para crear un temporizador para el elemento de trabajo. Proporcione una expresión lambda que realice el trabajo y use el parámetro delay para especificar cuánto tiempo espera el grupo de subprocesos para poder asignar el elemento de trabajo a un subproceso disponible. El retraso se especifica mediante una estructura TimeSpan.

Nota Puede usar CoreDispatcher.RunAsync para acceder a la interfaz de usuario y mostrar el progreso desde el elemento de trabajo.

En el ejemplo siguiente se crea un elemento de trabajo que se ejecuta en tres minutos:

TimeSpan delay = TimeSpan.FromMinutes(3);
            
ThreadPoolTimer DelayTimer = ThreadPoolTimer.CreateTimer(
    (source) =>
    {
        //
        // TODO: Work
        //
        
        //
        // Update the UI thread by using the UI core dispatcher.
        //
        Dispatcher.RunAsync(
            CoreDispatcherPriority.High,
            () =>
            {
                //
                // UI components can be accessed within this scope.
                //

            });

    }, delay);

TimeSpan delay;
delay.Duration = 3 * 60 * 10000000; // 10,000,000 ticks per second

ThreadPoolTimer ^ DelayTimer = ThreadPoolTimer::CreateTimer(
        ref new TimerElapsedHandler([this](ThreadPoolTimer^ source)
        {
            //
            // TODO: Work
            //
            
            //
            // Update the UI thread by using the UI core dispatcher.
            //
            Dispatcher->RunAsync(CoreDispatcherPriority::High,
                ref new DispatchedHandler([this]()
                {
                    //
                    // UI components can be accessed within this scope.
                    //

                    ExampleUIUpdateMethod("Timer completed.");

                }));

        }), delay);

Proporcionar un controlador de finalización

De ser necesario, gestione la cancelación y la finalización del elemento de trabajo con un TimerDestroyedHandler. Utilice la sobrecarga CreateTimer para proporcionar una expresión lambda adicional. Esto se ejecuta cuando se cancela el temporizador o cuando se completa el elemento de trabajo.

En el ejemplo siguiente se crea un temporizador que envía el elemento de trabajo y se llama a un método cuando finaliza el elemento de trabajo o se cancela el temporizador:

TimeSpan delay = TimeSpan.FromMinutes(3);
            
bool completed = false;

ThreadPoolTimer DelayTimer = ThreadPoolTimer.CreateTimer(
    (source) =>
    {
        //
        // TODO: Work
        //

        //
        // Update the UI thread by using the UI core dispatcher.
        //
        Dispatcher.RunAsync(
                CoreDispatcherPriority.High,
                () =>
                {
                    //
                    // UI components can be accessed within this scope.
                    //

                });

        completed = true;
    },
    delay,
    (source) =>
    {
        //
        // TODO: Handle work cancellation/completion.
        //


        //
        // Update the UI thread by using the UI core dispatcher.
        //
        Dispatcher.RunAsync(
            CoreDispatcherPriority.High,
            () =>
            {
                //
                // UI components can be accessed within this scope.
                //

                if (completed)
                {
                    // Timer completed.
                }
                else
                {
                    // Timer cancelled.
                }

            });
    });

TimeSpan delay;
delay.Duration = 3 * 60 * 10000000; // 10,000,000 ticks per second

completed = false;

ThreadPoolTimer ^ DelayTimer = ThreadPoolTimer::CreateTimer(
        ref new TimerElapsedHandler([&](ThreadPoolTimer ^ source)
        {
            //
            // TODO: Work
            //

            //
            // Update the UI thread by using the UI core dispatcher.
            //
            Dispatcher->RunAsync(CoreDispatcherPriority::High,
                ref new DispatchedHandler([&]()
                {
                    //
                    // UI components can be accessed within this scope.
                    //

                }));

            completed = true;

        }),
        delay,
        ref new TimerDestroyedHandler([&](ThreadPoolTimer ^ source)
        {
            //
            // TODO: Handle work cancellation/completion.
            //

            Dispatcher->RunAsync(CoreDispatcherPriority::High,
                ref new DispatchedHandler([&]()
                {
                    //
                    // Update the UI thread by using the UI core dispatcher.
                    //

                    if (completed)
                    {
                        // Timer completed.
                    }
                    else
                    {
                        // Timer cancelled.
                    }

                }));
        }));

Cancelar el temporizador

Si el temporizador sigue contando, pero el elemento de trabajo ya no es necesario, llame a Cancelar. El temporizador se cancela y el elemento de trabajo no se enviará al grupo de subprocesos.

DelayTimer.Cancel();

DelayTimer->Cancel();

Observaciones

Las aplicaciones de la Plataforma universal de Windows (UWP) no pueden usar Thread.Sleep porque puede bloquear el subproceso de la interfaz de usuario. Puede usar un ThreadPoolTimer para crear un elemento de trabajo en su lugar, y esto retrasará la tarea realizada por el elemento de trabajo sin bloquear el subproceso de la interfaz de usuario.

Consulte el de ejemplo del grupo de subprocesos de para obtener un ejemplo de código completo que muestre los elementos de trabajo, los elementos de trabajo del temporizador y los elementos de trabajo periódicos. El ejemplo de código se escribió originalmente para Windows 8.1, pero el código se puede volver a usar en Windows 10.

Para obtener información sobre los temporizadores periódicos, consulte Crear un elemento de trabajo periódico.

 

  • Last updated on