Condividi tramite

Timer

.NET offre tre timer da usare in un ambiente multithreading:

Annotazioni

Alcune implementazioni di .NET possono includere timer aggiuntivi:

  • System.Windows.Forms.Timer: componente Windows Form che genera un evento a intervalli regolari. Il componente non ha un'interfaccia utente ed è progettato per l'uso in un ambiente a thread singolo.
  • System.Web.UI.Timer: un componente ASP.NET che esegue postback asincroni o sincroni di pagine Web a intervalli regolari.
  • System.Windows.Threading.DispatcherTimer: un timer integrato nella coda Dispatcher che viene elaborato a intervalli di tempo specifici e con una priorità definita.

La classe System.Threading.Timer

La System.Threading.Timer classe consente di chiamare continuamente un delegato a intervalli di tempo specificati. È anche possibile usare questa classe per pianificare una singola chiamata a un delegato in un intervallo di tempo specificato. Il delegato viene eseguito su un ThreadPool thread.

Quando si crea un System.Threading.Timer oggetto, si specifica un TimerCallback delegato che definisce il metodo di callback, un oggetto di stato facoltativo passato al callback, la quantità di tempo da ritardare prima della prima chiamata del callback e l'intervallo di tempo tra le chiamate di callback. Per annullare un timer in sospeso, chiamare il Timer.Dispose metodo .

Nell'esempio seguente viene creato un timer che chiama il delegato fornito per la prima volta dopo un secondo (1000 millisecondi) e quindi lo chiama ogni due secondi. L'oggetto stato nell'esempio viene usato per contare il numero di chiamate del delegato. Il timer viene arrestato quando il delegato è stato chiamato almeno 10 volte.

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

Per altre informazioni ed esempi, vedere System.Threading.Timer.

La classe System.Timers.Timer

Un altro timer che può essere usato in un ambiente multithreading è System.Timers.Timer che per impostazione predefinita genera un evento in un ThreadPool thread.

Quando si crea un System.Timers.Timer oggetto, è possibile specificare l'intervallo di tempo in cui generare un Elapsed evento. Utilizzare la Enabled proprietà per indicare se un timer deve generare un Elapsed evento. Se è necessario che venga generato un Elapsed evento una sola volta dopo che è trascorso l'intervallo specificato, impostare il AutoReset su false. Il valore predefinito della AutoReset proprietà è true, il che significa che un Elapsed evento viene generato regolarmente all'intervallo definito dalla Interval proprietà .

Per altre informazioni ed esempi, vedere System.Timers.Timer.

Classe System.Threading.PeriodicTimer

La System.Threading.PeriodicTimer classe consente di attendere i singoli tick di un intervallo specificato, eseguendo un'operazione dopo aver chiamato PeriodicTimer.WaitForNextTickAsync.

Quando si crea un System.Threading.PeriodicTimer oggetto, si specifica un TimeSpan oggetto che determina il periodo di tempo tra ogni tick del timer. Anziché passare un callback o impostare un gestore eventi come nelle classi timer precedenti, è possibile eseguire operazioni direttamente nell'ambito, in attesa di avanzare il timer in base WaitForNextTickAsync all'intervallo specificato.

Il WaitForNextTickAsync metodo restituisce un ValueTask<bool>; true al termine dell'attivazione del timer e false quando il timer è stato annullato chiamando PeriodicTimer.Dispose. WaitForNextTickAsync può facoltativamente accettare un CancellationToken, che risulta in un TaskCanceledException quando è stato richiesto un annullamento.

Per altre informazioni, vedere System.Threading.PeriodicTimer.

Vedere anche