Temporizadores
O .NET fornece três temporizadores para usar em um ambiente multithreaded:
- System.Threading.Timer, que executa um único método de retorno de chamada em um ThreadPool thread em intervalos regulares.
- System.Timers.Timer, que, por padrão, gera um evento em um ThreadPool thread em intervalos regulares.
- System.Threading.PeriodicTimer, que permite que o chamador execute o trabalho depois de aguardar ticks individuais do temporizador.
Nota
Algumas implementações .NET podem incluir temporizadores adicionais:
- System.Windows.Forms.Timer: um componente do Windows Forms que dispara um evento em intervalos regulares. O componente não tem interface de usuário e é projetado para uso em um ambiente de thread único.
- System.Web.UI.Timer: um componente ASP.NET que executa postbacks assíncronos ou síncronos de páginas da Web em um intervalo regular.
- System.Windows.Threading.DispatcherTimer: um temporizador integrado na fila Dispatcher que é processado em um intervalo de tempo especificado e com uma prioridade especificada.
A classe System.Threading.Timer
A System.Threading.Timer classe permite que você chame continuamente um delegado em intervalos de tempo especificados. Você também pode usar essa classe para agendar uma única chamada para um delegado em um intervalo de tempo especificado. O delegado é executado em um ThreadPool thread.
Ao criar um System.Threading.Timer objeto, você especifica um TimerCallback delegado que define o método de retorno de chamada, um objeto de estado opcional que é passado para o retorno de chamada, a quantidade de tempo de atraso antes da primeira chamada do retorno de chamada e o intervalo de tempo entre as invocações de retorno de chamada. Para cancelar um temporizador pendente, chame o Timer.Dispose método.
O exemplo a seguir cria um temporizador que chama o delegado fornecido pela primeira vez após um segundo (1000 milissegundos) e, em seguida, chama-o a cada dois segundos. O objeto state no exemplo é usado para contar quantas vezes o delegado é chamado. O temporizador é interrompido quando o delegado foi chamado pelo menos 10 vezes.
using namespace System;
using namespace System::Threading;
ref class TimerState
{
public:
int counter;
};
ref class Example
{
private:
static Timer^ timer;
public:
static void TimerTask(Object^ state)
{
Console::WriteLine("{0:HH:mm:ss.fff}: starting a new callback.", DateTime::Now);
TimerState^ timerState = dynamic_cast<TimerState^>(state);
Interlocked::Increment(timerState->counter);
}
static void Main()
{
TimerCallback^ tcb = gcnew TimerCallback(&TimerTask);
TimerState^ state = gcnew TimerState();
state->counter = 0;
timer = gcnew Timer(tcb, state, 1000, 2000);
while (state->counter <= 10)
{
Thread::Sleep(1000);
}
timer->~Timer();
Console::WriteLine("{0:HH:mm:ss.fff}: done.", DateTime::Now);
}
};
int main()
{
Example::Main();
}
using System;
using System.Threading;
using System.Threading.Tasks;
class Program
{
private static Timer timer;
static void Main(string[] args)
{
var timerState = new TimerState { Counter = 0 };
timer = new Timer(
callback: new TimerCallback(TimerTask),
state: timerState,
dueTime: 1000,
period: 2000);
while (timerState.Counter <= 10)
{
Task.Delay(1000).Wait();
}
timer.Dispose();
Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: done.");
}
private static void TimerTask(object timerState)
{
Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: starting a new callback.");
var state = timerState as TimerState;
Interlocked.Increment(ref state.Counter);
}
class TimerState
{
public int Counter;
}
}
Imports System.Threading
Module Program
Private Timer As Timer
Sub Main(args As String())
Dim StateObj As New TimerState
StateObj.Counter = 0
Timer = New Timer(New TimerCallback(AddressOf TimerTask), StateObj, 1000, 2000)
While StateObj.Counter <= 10
Task.Delay(1000).Wait()
End While
Timer.Dispose()
Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: done.")
End Sub
Private Sub TimerTask(ByVal StateObj As Object)
Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: starting a new callback.")
Dim State As TimerState = CType(StateObj, TimerState)
Interlocked.Increment(State.Counter)
End Sub
Private Class TimerState
Public Counter As Integer
End Class
End Module
Para obter mais informações e exemplos, consulte System.Threading.Timer.
A classe System.Timers.Timer
Outro temporizador que pode ser usado em um ambiente multithreaded é System.Timers.Timer que, por padrão, gera um evento em um ThreadPool thread.
Ao criar um System.Timers.Timer objeto, você pode especificar o intervalo de tempo no qual gerar um Elapsed evento. Use a Enabled propriedade para indicar se um temporizador deve gerar um Elapsed evento. Se você precisar que um Elapsed evento seja gerado apenas uma vez após o intervalo especificado ter decorrido, defina como AutoResetfalse. O valor padrão da propriedade é , o AutoReset que significa que um Elapsed evento é gerado regularmente no intervalo definido pela Intervaltruepropriedade.
Para obter mais informações e exemplos, consulte System.Timers.Timer.
A classe System.Threading.PeriodicTimer
A System.Threading.PeriodicTimer classe permite que você aguarde ticks individuais de um intervalo especificado, executando o trabalho após a chamada PeriodicTimer.WaitForNextTickAsync.
Ao criar um System.Threading.PeriodicTimer objeto, você especifica um TimeSpan que determina o período de tempo entre cada tick do temporizador. Em vez de passar um retorno de chamada ou definir um manipulador de eventos como nas classes de timer anteriores, você executa o trabalho diretamente no escopo, aguardando WaitForNextTickAsync para avançar o temporizador pelo intervalo especificado.
O WaitForNextTickAsync método retorna um ValueTask<bool>; true após o disparo bem-sucedido do temporizador e false quando o temporizador foi cancelado chamando PeriodicTimer.Dispose. WaitForNextTickAsync opcionalmente aceita um CancellationToken, o que resulta em um TaskCanceledException quando um cancelamento foi solicitado.
Para obter mais informações, veja System.Threading.PeriodicTimer.
