Delen via

Timers

  • Artikel

.NET biedt drie timers die kunnen worden gebruikt in een omgeving met meerderereads:

Notitie

Sommige .NET-implementaties kunnen extra timers bevatten:

  • System.Windows.Forms.Timer: een Windows Forms-onderdeel waarmee een gebeurtenis regelmatig wordt geactiveerd. Het onderdeel heeft geen gebruikersinterface en is ontworpen voor gebruik in een omgeving met één thread.
  • System.Web.UI.Timer: een ASP.NET onderdeel dat asynchrone of synchrone postbacks op webpagina's uitvoert met een regelmatig interval.
  • System.Windows.Threading.DispatcherTimer: een timer die is geïntegreerd in de Dispatcher wachtrij die wordt verwerkt met een opgegeven tijdsinterval en met een opgegeven prioriteit.

De klasse System.Threading.Timer

Met de System.Threading.Timer klasse kunt u continu een gemachtigde aanroepen met opgegeven tijdsintervallen. U kunt deze klasse ook gebruiken om één aanroep naar een gemachtigde in een opgegeven tijdsinterval te plannen. De gemachtigde wordt uitgevoerd op een ThreadPool thread.

Wanneer u een System.Threading.Timer object maakt, geeft u een TimerCallback gemachtigde op die de callback-methode definieert, een optioneel statusobject dat wordt doorgegeven aan de callback, de hoeveelheid tijd die moet worden vertraagd voordat de eerste aanroep van de callback wordt aangeroepen en het tijdsinterval tussen aanroepen van callback. Als u een timer in behandeling wilt annuleren, roept u de Timer.Dispose methode aan.

In het volgende voorbeeld wordt een timer gemaakt waarmee de opgegeven gemachtigde voor de eerste keer na één seconde (1000 milliseconden) wordt aangeroepen en deze vervolgens om de twee seconden wordt aangeroepen. Het statusobject in het voorbeeld wordt gebruikt om te tellen hoe vaak de gemachtigde wordt aangeroepen. De timer wordt gestopt wanneer de gemachtigde minstens 10 keer is aangeroepen.

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

Zie voor meer informatie en voorbeelden System.Threading.Timer.

De klasse System.Timers.Timer

Een andere timer die kan worden gebruikt in een omgeving met meerdere threads, is System.Timers.Timer dat standaard een gebeurtenis op een ThreadPool thread wordt gegenereerd.

Wanneer u een System.Timers.Timer object maakt, kunt u het tijdsinterval opgeven waarin een Elapsed gebeurtenis moet worden gegenereerd. Gebruik de Enabled eigenschap om aan te geven of een timer een Elapsed gebeurtenis moet genereren. Als u wilt dat een Elapsed gebeurtenis slechts eenmaal wordt gegenereerd nadat het opgegeven interval is verstreken, stelt u het AutoReset in op false. De standaardwaarde van de AutoReset eigenschap is true, wat betekent dat een Elapsed gebeurtenis regelmatig wordt gegenereerd met het interval dat door de Interval eigenschap is gedefinieerd.

Zie voor meer informatie en voorbeelden System.Timers.Timer.

De klasse System.Threading.PeriodicTimer

Met de System.Threading.PeriodicTimer klasse kunt u wachten op afzonderlijke tikken van een opgegeven interval, waarbij u na het aanroepen PeriodicTimer.WaitForNextTickAsyncwerk uitvoert.

Wanneer u een System.Threading.PeriodicTimer object maakt, geeft u een TimeSpan object op dat de tijdsduur bepaalt tussen elke maatstreep van de timer. In plaats van een callback door te geven of een gebeurtenis-handler in te stellen zoals in de vorige timerklassen, voert u rechtstreeks werk uit binnen het bereik, wachtend WaitForNextTickAsync op het vooruitgaan van de timer met het opgegeven interval.

De WaitForNextTickAsync methode retourneert een ValueTask<bool>; true bij het starten van de timer en false wanneer de timer is geannuleerd door aan te roepen PeriodicTimer.Dispose. WaitForNextTickAsync accepteert eventueel een CancellationToken, wat resulteert in een TaskCanceledException wanneer een annulering is aangevraagd.

Zie System.Threading.PeriodicTimer voor meer informatie.

Zie ook