Compartilhar via

Temporizadores

O .NET fornece três temporizadores a serem usados em um ambiente multithreaded:

Observação

Algumas implementações do .NET podem incluir temporizadores adicionais:

  • System.Windows.Forms.Timer: um componente do Windows Forms que aciona um evento em intervalos regulares. O componente não tem interface do usuário e foi projetado para uso em um ambiente de thread único.
  • System.Web.UI.Timer: um componente ASP.NET que executa postbacks de página da Web síncrona ou assíncrona em intervalos regulares.
  • System.Windows.Threading.DispatcherTimer: um temporizador integrado na fila Dispatcher que é processada em um intervalo de tempo especificado e em 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 uma linha de execução ThreadPool.

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 a função de retorno, o tempo para atraso antes da primeira invocação e o intervalo 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 o chama a cada dois segundos. O objeto de estado no exemplo é usado para contar quantas vezes o delegado é chamado. O temporizador é interrompido quando o delegado é chamado pelo menos 10 vezes.

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 acionado apenas uma vez após o intervalo especificado decorrido, defina AutoReset como false. O valor padrão da propriedade AutoReset é true, o que significa que um evento Elapsed é gerado regularmente no intervalo definido pela propriedade Interval.

Para obter mais informações e exemplos, consulte System.Timers.Timer.

A classe System.Threading.PeriodicTimer

A System.Threading.PeriodicTimer classe permite aguardar tiques 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 tique do temporizador. Em vez de passar um retorno de chamada ou definir um manipulador de eventos como nas classes de temporizador 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 disparo bem-sucedido do temporizador e false quando o temporizador foi cancelado chamando PeriodicTimer.Dispose. WaitForNextTickAsync opcionalmente aceita um CancellationToken, que resulta em um TaskCanceledException quando um cancelamento foi solicitado.

Para obter mais informações, consulte System.Threading.PeriodicTimer.

Consulte também