Crear un elemento de trabajo periódico
API importantes
Obtén información sobre cómo crear un elemento de trabajo que se repita periódicamente.
Creación del elemento de trabajo periódico
Use el método CreatePeriodicTimer para crear un elemento de trabajo periódico. Proporcione una expresión lambda que realice el trabajo y use el parámetro period para especificar el intervalo entre envíos. El período se especifica mediante una estructura TimeSpan. El elemento de trabajo se volverá a enviar cada vez que transcurre el período, por lo que asegúrese de que el período sea lo suficientemente largo como para completar el trabajo.
CreateTimer devuelve un objeto ThreadPoolTimer . Almacene este objeto en caso de que se deba cancelar el temporizador.
Nota Evite especificar un valor de cero (o cualquier valor inferior a un milisegundo) para el intervalo. Esto hace que el temporizador periódico se comporte como un temporizador de un solo disparo en su lugar.
Nota Puede usar CoreDispatcher.RunAsync para acceder a la interfaz de usuario y mostrar el progreso desde el elemento de trabajo.
En el ejemplo siguiente se crea un elemento de trabajo que se ejecuta una vez cada 60 segundos:
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);
Controlar la cancelación del elemento de trabajo periódico (opcional)
Si es necesario, puede controlar la cancelación del temporizador periódico con timerDestroyedHandler. Use la sobrecarga CreatePeriodicTimer para proporcionar una expresión lambda adicional que controle la cancelación del elemento de trabajo periódico.
En el ejemplo siguiente se crea un elemento de trabajo periódico que se repite cada 60 segundos y también proporciona un controlador de cancelación:
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.
}));
}));
Cancelar el temporizador
Cuando sea necesario, llame al método Cancel para impedir que se repita el elemento de trabajo periódico. Si el elemento de trabajo se está ejecutando cuando se cancela el temporizador periódico, se puede completar. Se llama a TimerDestroyedHandler (si se proporciona) cuando se han completado todas las instancias del elemento de trabajo periódico.
PeriodicTimer.Cancel();
PeriodicTimer->Cancel();
Comentarios
Para obtener información sobre los temporizadores de uso único, vea Usar un temporizador para enviar un elemento de trabajo.