Usar um temporizador para enviar um item de trabalho

APIs importantes

Saiba como criar um item de trabalho que é executado quando um temporizador expira.

Criar um temporizador de tiro único

Use o método CreateTimer para criar um temporizador para o item de trabalho. Forneça um lambda que realiza o trabalho e use o parâmetro de atraso para especificar por quanto tempo o pool de threads aguarda antes que ele possa atribuir o item de trabalho a um thread disponível. O atraso é especificado usando uma estrutura TimeSpan .

Note

Em aplicativos WinUI 3, use DispatcherQueue.TryEnqueue de Microsoft.UI.Dispatching.DispatcherQueue para acessar a thread da interface do usuário e exibir o progresso do item de trabalho. Confira a visão geral do DispatcherQueue para obter detalhes.

O exemplo a seguir cria um item de trabalho executado em três 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);

Forneça um manipulador de conclusão

Se necessário, gerencie o cancelamento e a conclusão do item de trabalho com um TimerDestroyedHandler. Use a sobrecarga CreateTimer para fornecer um lambda adicional. Isso é executado quando o temporizador é cancelado ou quando o item de trabalho é concluído.

O exemplo a seguir cria um temporizador que envia o item de trabalho e chama um método quando o item de trabalho é concluído ou o temporizador é cancelado:

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

Se o temporizador ainda estiver em contagem regressiva, mas o item de trabalho não for mais necessário, chame Cancelar. O temporizador é cancelado e o item de trabalho não será enviado para o pool de threads.

DelayTimer.Cancel();

DelayTimer->Cancel();

Remarks

Aplicativos do Windows devem evitar Thread.Sleep porque ele bloqueia a thread chamadora, o que pode fazer com que a interface do usuário pare de responder se for chamado na thread da interface do usuário. Você pode usar um ThreadPoolTimer para criar um item de trabalho, o que atrasará a tarefa executada pelo item de trabalho sem bloquear a thread da interface do usuário.

Consulte o exemplo do pool de threads para ver um exemplo de código completo que demonstra itens de trabalho, itens de trabalho com temporizador e itens de trabalho periódicos. O exemplo de código foi originalmente escrito para Windows 8.1 mas o código pode ser reutilize no Windows 10.

Para obter informações sobre temporizadores recorrentes, consulte Criar um item de trabalho periódico.

  • Last updated on