Crear un elemento de trabajo periódico

API importantes

Obtenga información sobre cómo crear un elemento de trabajo que se repita periódicamente.

Creación del elemento de trabajo periódico

Use el método CreatePeriodicTimer para crear un elemento de trabajo periódico. Proporcione una expresión lambda que realice el trabajo y use el parámetro period para especificar el intervalo entre envíos. El período se especifica mediante una estructura TimeSpan . El elemento de trabajo se volverá a enviar cada vez que transcurre el período, por lo que asegúrese de que el período sea lo suficientemente largo como para completar el trabajo.

CreatePeriodicTimer devuelve un objeto ThreadPoolTimer . Almacene este objeto en caso de que se deba cancelar el temporizador.

Note

Evite especificar un valor de cero (o cualquier valor inferior a un milisegundo) para el intervalo. Esto hace que el temporizador periódico se comporte como un temporizador de una sola ejecución.

Note

En las aplicaciones WinUI 3, utiliza DispatcherQueue.TryEnqueue de Microsoft.UI.Dispatching.DispatcherQueue para acceder al hilo de la interfaz de usuario y mostrar el progreso del elemento de trabajo. Consulte la introducción a DispatcherQueue para obtener más información.

En el ejemplo siguiente se crea un elemento de trabajo que se ejecuta una vez cada 60 segundos:

TimeSpan period = TimeSpan.FromSeconds(60);

ThreadPoolTimer PeriodicTimer = ThreadPoolTimer.CreatePeriodicTimer((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.
                //

            });

    }, period);

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

ThreadPoolTimer ^ PeriodicTimer = ThreadPoolTimer::CreatePeriodicTimer(
        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.
                    //
                        
                }));

        }), period);

Administrar la cancelación del elemento de trabajo periódico (opcional)

Si es necesario, puede controlar la cancelación del temporizador periódico con timerDestroyedHandler. Utilice la sobrecarga CreatePeriodicTimer para proporcionar una función lambda adicional que administre la cancelación del elemento de trabajo periódico.

En el ejemplo siguiente se crea un elemento de trabajo periódico que se repite cada 60 segundos y también proporciona un controlador de cancelación:

using Windows.System.Threading;

    TimeSpan period = TimeSpan.FromSeconds(60);

    ThreadPoolTimer PeriodicTimer = ThreadPoolTimer.CreatePeriodicTimer((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.
                //

            });
    },
    period,
    (source) =>
    {
        //
        // TODO: Handle periodic timer cancellation.
        //

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

                // Periodic timer cancelled.

            }));
    });

using namespace Windows::System::Threading;
using namespace Windows::UI::Core;

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

ThreadPoolTimer ^ PeriodicTimer = ThreadPoolTimer::CreatePeriodicTimer(
        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.
                    //

                }));

        }),
        period,
        ref new TimerDestroyedHandler([&](ThreadPoolTimer ^ source)
        {
            //
            // TODO: Handle periodic timer cancellation.
            //

            Dispatcher->RunAsync(CoreDispatcherPriority::High,
                ref new DispatchedHandler([&]()
                {
                    //
                    // UI components can be accessed within this scope.
                    //

                    // Periodic timer cancelled.

                }));
        }));

Cancelar el temporizador

Cuando sea necesario, llame al método Cancel para impedir que se repita el elemento de trabajo periódico. Si el elemento de trabajo se está ejecutando cuando se cancela el temporizador periódico, se permite que finalice. Se invoca a TimerDestroyedHandler (si se proporciona) cuando se han completado todas las instancias del elemento de trabajo periódico.

PeriodicTimer.Cancel();

PeriodicTimer->Cancel();

Remarks

Para obtener información sobre los temporizadores de uso único, vea Usar un temporizador para enviar un elemento de trabajo.

  • Last updated on