Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Les APIs importantes
Découvrez comment créer un élément de travail qui se répète 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 une expression lambda qui effectue le travail et utilisez le paramètre 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 minuteur périodique à se comporter comme un minuteur à déclenchement unique.
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 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 un 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 empêcher 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 permis de terminer. Le TimerDestroyedHandler (si fourni) est appelé lorsque toutes les instances de l’élément de travail périodique sont terminées.
PeriodicTimer.Cancel();
PeriodicTimer->Cancel();
Remarques
Pour plus d’informations sur les minuteurs à usage unique, consultez Utiliser un minuteur pour envoyer un élément de travail.