Partager via

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

Les APIs importantes

Découvrez comment créer une tâche qui s’exécute après qu’un minuteur s’est écoulé.

Créer un minuteur à déclenchement 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 .

Remarque Vous pouvez utiliser CoreDispatcher.RunAsync pour accéder à l’interface utilisateur et afficher la progression 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 de complétion

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 valeur 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 à rebours, mais que l’élément de travail n’est plus nécessaire, utilisez Annuler. Le minuteur est annulé et l’élément de travail ne sera pas soumis au pool de threads.

DelayTimer.Cancel();

DelayTimer->Cancel();

Remarques

Les applications de plateforme Windows universelle (UWP) ne peuvent pas utiliser Thread.Sleep , car elles peuvent 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 tâches, les tâches temporisées et les tâches 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.

 

  • Last updated on