Partager via

Créer un élément de travail périodique

  • Article

API importantes

Découvrez comment créer un élément de travail qui se reproduit régulièrement.

Créer l’élément de travail périodique

Utilisez la méthode CreatePeriodicTimer pour créer un élément de travail périodique. Fournissez un lambda qui effectue le travail et utilisez le paramètre de période pour spécifier l’intervalle entre les soumissions. La période est spécifiée à l’aide d’une structure TimeSpan . L’élément de travail sera resoumise chaque fois que la période s’est écoulée. Assurez-vous que la période est suffisamment longue pour que le travail se termine.

CreateTimer retourne un objet ThreadPoolTimer . Stockez cet objet si le minuteur doit être annulé.

Remarque : Évitez de spécifier la valeur zéro (ou toute valeur inférieure à une milliseconde) pour l’intervalle. Cela entraîne le comportement du minuteur périodique en tant que minuteur à un seul coup.

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 une fois toutes les 60 secondes :

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

Gérer l’annulation de l’élément de travail périodique (facultatif)

Si nécessaire, vous pouvez gérer l’annulation du minuteur périodique avec un TimerDestroyedHandler. Utilisez la surcharge CreatePeriodicTimer pour fournir une lambda supplémentaire qui gère l’annulation de l’élément de travail périodique.

L’exemple suivant crée un élément de travail périodique qui se répète toutes les 60 secondes et fournit également un gestionnaire d’annulation :

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.

                }));
        }));

Annuler le minuteur

Si nécessaire, appelez la méthode Cancel pour arrêter la répétition de l’élément de travail périodique. Si l’élément de travail est en cours d’exécution lorsque le minuteur périodique est annulé, il est autorisé à se terminer. TimerDestroyedHandler (si fourni) est appelé lorsque toutes les instances de l’élément de travail périodique sont terminées.

PeriodicTimer.Cancel();

PeriodicTimer->Cancel();

Notes

Pour plus d’informations sur les minuteurs à usage unique, consultez Utiliser un minuteur pour envoyer un élément de travail.