Partilhar via

Temporizadores

O .NET fornece três temporizadores para usar em um ambiente multithreaded:

Observação

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 Web a 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 numa ThreadPool thread.

Ao criar um System.Threading.Timer objeto, especifica um TimerCallback delegado que define o método de callback, um objeto de estado opcional que é passado para o callback, o tempo de atraso antes da primeira invocação do callback e o intervalo de tempo entre as sucessivas invocações do callback. 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 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 precisar que um Elapsed evento seja levantado apenas uma vez após o intervalo especificado ter decorrido, defina AutoReset para false. O valor padrão da propriedade AutoReset é true, o que significa que um evento Elapsed é lançado 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 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, consulte System.Threading.PeriodicTimer.

Ver também