Partager via

Utiliser un minuteur pour envoyer un élément de travail

  • Article

API importantes

Découvrez comment créer un élément de travail qui s’exécute une fois le délai du minuteur écoulé.

Créer un minuteur à capture unique

Utilisez la méthode CreateTimer pour créer un minuteur pour l’élément de travail. Fournissez une lambda qui effectue le travail et utilisez le paramètre de délai pour spécifier la durée pendant laquelle le pool de threads attend avant de pouvoir affecter l’élément de travail à un thread disponible. Le délai est spécifié à l’aide d’une structure TimeSpan .

Notez que vous pouvez utiliser CoreDispatcher.RunAsync pour accéder à l’interface utilisateur et afficher la progression à partir de l’élément de travail.

L’exemple suivant crée un élément de travail qui s’exécute en trois minutes :

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);

Fournir un gestionnaire d’achèvement

Si nécessaire, gérez l’annulation et l’achèvement de l’élément de travail avec un TimerDestroyedHandler. Utilisez la surcharge CreateTimer pour fournir une expression lambda supplémentaire. Cela s’exécute lorsque le minuteur est annulé ou lorsque l’élément de travail est terminé.

L’exemple suivant crée un minuteur qui envoie l’élément de travail et appelle une méthode lorsque l’élément de travail se termine ou que le minuteur est annulé :

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

                }));
        }));

Annuler le minuteur

Si le minuteur compte toujours, mais que l’élément de travail n’est plus nécessaire, appelez Annuler. Le minuteur est annulé et l’élément de travail ne sera pas soumis au pool de threads.

DelayTimer.Cancel();

DelayTimer->Cancel();

Notes

les applications plateforme Windows universelle (UWP) ne peuvent pas utiliser Thread.Sleep, car il peut bloquer le thread d’interface utilisateur. Vous pouvez utiliser un ThreadPoolTimer pour créer un élément de travail à la place, ce qui retardera la tâche effectuée par l’élément de travail sans bloquer le thread d’interface utilisateur.

Consultez l’exemple de pool de threads pour obtenir un exemple de code complet qui illustre les éléments de travail, les éléments de travail du minuteur et les éléments de travail périodiques. L’exemple de code a été écrit à l’origine pour Windows 8.1, mais le code peut être réutilisé dans Windows 10.

Pour plus d’informations sur les minuteurs répétitifs, consultez Créer un élément de travail périodique.