Criar um item de trabalho periódico

APIs importantes

Aprenda a criar um item de trabalho que se repita periodicamente.

Crie o item de trabalho periódico

Use o método CreatePeriodicTimer para criar um item de trabalho periódico. Forneça um lambda que realize o trabalho e use o parâmetro de período para especificar o intervalo entre submissões. O período é especificado usando uma estrutura TimeSpan . O item do trabalho será reentregue sempre que o período terminar, por isso certifique-se de que o período é suficientemente longo para o trabalho ser concluído.

CreatePeriodicTimer devolve um objeto ThreadPoolTimer . Guarda este objeto caso o temporizador precise de ser cancelado.

Observação

Evite especificar um valor zero (ou qualquer valor inferior a um milissegundo) para o intervalo. Isto faz com que o temporizador periódico passe a comportar-se como um temporizador de disparo único.

Observação

Nas aplicações do WinUI 3, usa DispatcherQueue.TryEnqueue o from Microsoft.UI.Dispatching.DispatcherQueue para aceder ao tópico da interface e mostrar o progresso do item de trabalho. Consulte a visão geral do DispatcherQueue para mais detalhes.

O exemplo seguinte cria um item de trabalho que é executado uma vez a 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);

Lidar com o cancelamento do item de trabalho periódico (opcional)

Se necessário, pode tratar o cancelamento do temporizador periódico com um TimerDestroyedHandler. Utilize a sobrecarga CreatePeriodicTimer para fornecer uma expressão lambda adicional que trate do cancelamento do item de trabalho periódico.

O exemplo seguinte cria um item de trabalho periódico que se repete a cada 60 segundos e também fornece um manipulador de cancelamento:

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 o temporizador

Quando necessário, chame o método Cancelar para impedir que o item de trabalho periódico se repita. Se o item de trabalho estiver a correr quando o temporizador periódico for cancelado, é permitido concluir. O TimerDestroyedHandler (caso seja fornecido) é chamado quando todas as instâncias do item de trabalho periódico tiverem sido concluídas.

PeriodicTimer.Cancel();

PeriodicTimer->Cancel();

Remarks

Para informações sobre temporizadores de uso único, consulte Usar um temporizador para submeter um item de trabalho.

  • Last updated on