DispatcherTimer Classe

Definição

Namespace:

Windows.UI.Xaml

Fornece um temporizador integrado à fila do Dispatcher , que é processado em um intervalo de tempo especificado e em uma prioridade especificada.

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
class DispatcherTimer

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public class DispatcherTimer

Public Class DispatcherTimer

Herança

Object IInspectable DispatcherTimer

Atributos

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Requisitos do Windows

Família de dispositivos	Windows 10 (introduzida na 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (introduzida na v1.0)

Exemplos

Este código de exemplo implementa um temporizador de estilo de console simples que grava dados em um TextBlock chamado TimerLog (XAML que define TimerLog não é mostrado). O valor interval é definido como 1 e o log exibe o tempo decorrido real para cada Tick.

DispatcherTimer dispatcherTimer;
DateTimeOffset startTime;
DateTimeOffset lastTime;
DateTimeOffset stopTime;
int timesTicked = 1;
int timesToTick = 10;

public void DispatcherTimerSetup()
{
    dispatcherTimer = new DispatcherTimer();
    dispatcherTimer.Tick += dispatcherTimer_Tick;
    dispatcherTimer.Interval = new TimeSpan(0, 0, 1);
    //IsEnabled defaults to false
    TimerLog.Text += "dispatcherTimer.IsEnabled = " + dispatcherTimer.IsEnabled + "\n";
    startTime = DateTimeOffset.Now;
    lastTime = startTime;
    TimerLog.Text += "Calling dispatcherTimer.Start()\n";
    dispatcherTimer.Start();
    //IsEnabled should now be true after calling start
    TimerLog.Text += "dispatcherTimer.IsEnabled = " + dispatcherTimer.IsEnabled + "\n";
}

void dispatcherTimer_Tick(object sender, object e)
{
    DateTimeOffset time = DateTimeOffset.Now;
    TimeSpan span = time - lastTime;
    lastTime = time;
    //Time since last tick should be very very close to Interval
    TimerLog.Text += timesTicked + "\t time since last tick: " + span.ToString() + "\n";
    timesTicked++;
    if (timesTicked > timesToTick)
    {
        stopTime = time;
        TimerLog.Text += "Calling dispatcherTimer.Stop()\n";
        dispatcherTimer.Stop();
        //IsEnabled should now be false after calling stop
        TimerLog.Text += "dispatcherTimer.IsEnabled = " + dispatcherTimer.IsEnabled + "\n";
        span = stopTime - startTime;
        TimerLog.Text += "Total Time Start-Stop: " + span.ToString() + "\n";
    }
}
private void Page_Loaded_1(object sender, RoutedEventArgs e)
{
    DispatcherTimerSetup();
}

// MainPage.cpp
...
#include <chrono>
...
void MainPage::StartTimerAndRegisterHandler()
{
    Windows::UI::Xaml::DispatcherTimer timer;
    timer.Interval(std::chrono::milliseconds{ 500 });
    auto registrationtoken = timer.Tick({this, &MainPage::OnTick });
    timer.Start();
}

void MainPage::OnTick(Windows::Foundation::IInspectable const& /* sender */,
    Windows::Foundation::IInspectable const& /* e */)
{
    // do something on each tick here ...
}

// .cpp definition, .h not shown
void MainPage::StartTimerAndRegisterHandler() {
    auto timer = ref new Windows::UI::Xaml::DispatcherTimer();
    TimeSpan ts;
    ts.Duration = 500;
    timer->Interval = ts;
    timer->Start();
    auto registrationtoken = timer->Tick += ref new EventHandler<Object^>(this,&MainPage::OnTick);
}
void MainPage::OnTick(Object^ sender, Object^ e) {
    // do something on each tick here ...
}

Comentários

O DispatcherTimer pode ser usado para executar código no mesmo thread que produz o thread de interface do usuário. O código em execução nesse thread tem o privilégio de criar e modificar objetos que só podem ser criados e modificados no thread da interface do usuário. Para especificar que o código deve ser executado no thread da interface do usuário, defina a propriedade Interval e, em seguida, chame o método Start . O evento Tick é acionado após o tempo especificado em Intervalo ter decorrido. O tick continua disparando no mesmo Intervalo até que o método Stop seja chamado, o aplicativo seja encerrado ou o aplicativo seja suspenso (aciona Suspending).

Um cenário para DispatcherTimer é marcar propriedades em sensores em que as alterações nos valores do sensor não são puramente controladas por eventos ou os eventos não oferecem a granularidade desejada. Você pode ver isso no exemplo de Acelerômetro.

Outros cenários para DispatcherTimer incluem a verificação de alterações de estado que não têm eventos relacionados ou para atualizações periódicas da interface do usuário que não podem usar uma animação com storyboard ou uma associação bidirecional.

Dica

Se você estiver migrando o código do Microsoft Silverlight ou Windows Presentation Foundation (WPF), o DispatcherTimer e o Dispatcher relacionados estavam em um namespace System.Windows.Threading separado. Não há nenhum namespace Windows.UI.Xaml.Threading no Windows Runtime, portanto, essa classe está em Windows.UI.Xaml.

Se você não estiver fazendo nada com o thread da interface do usuário em seus manipuladores tick e apenas precisar de um temporizador, também poderá usar ThreadPoolTimer . Além disso, para técnicas como ThreadPoolTimer ou uma Tarefa .NET, você não está totalmente isolado do thread da interface do usuário. Você ainda pode atribuir ao thread da interface do usuário de forma assíncrona usando CoreDispatcher.RunAsync.

Construtores

DispatcherTimer()

Inicializa uma nova instância da classe DispatcherTimer .

Propriedades

Interval	Obtém ou define a quantidade de tempo entre tiques de temporizador.
IsEnabled	Obtém um valor que indica se o temporizador está em execução.

Métodos

Start()	Inicia o DispatcherTimer.
Stop()	Interrompe o DispatcherTimer.

Eventos

Tick	Ocorre quando termina o intervalo do temporizador.

Confira também

• CoreDispatcher
• ThreadPoolTimer