Sdílet prostřednictvím

Časovače

  • Článek

.NET poskytuje tři časovače pro použití v prostředí s více vlákny:

Poznámka:

Některé implementace .NET můžou zahrnovat další časovače:

  • System.Windows.Forms.Timer: komponenta model Windows Forms, která v pravidelných intervalech aktivuje událost. Komponenta nemá žádné uživatelské rozhraní a je navržená pro použití v prostředí s jedním vláknem.
  • System.Web.UI.Timer: komponenta ASP.NET, která provádí asynchronní nebo synchronní postbacky webových stránek v pravidelných intervalech.
  • System.Windows.Threading.DispatcherTimer: časovač integrovaný do Dispatcher fronty, který se zpracovává v zadaném časovém intervalu a v zadané prioritě.

System.Threading.Timer – třída

Třída System.Threading.Timer umožňuje nepřetržitě volat delegáta v zadaných časových intervalech. Tuto třídu můžete také použít k naplánování jednoho volání delegáta v zadaném časovém intervalu. Delegát se spustí ve vlákně ThreadPool .

Při vytváření objektu System.Threading.Timer zadáte delegáta TimerCallback , který definuje metodu zpětného volání, volitelný stavový objekt, který se předá zpětnému volání, dobu, po kterou se má zpoždění před prvním vyvoláním zpětného volání, a časový interval mezi voláním zpětného volání. Chcete-li zrušit čekající časovač, zavolejte metodu Timer.Dispose .

Následující příklad vytvoří časovač, který volá poskytnutého delegáta poprvé po jedné sekundě (1000 milisekund) a potom ji volá každých dvě sekundy. Objekt stavu v příkladu slouží ke zjištění, kolikrát je delegát volána. Časovač se zastaví, když byl delegát volána nejméně 10krát.

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

Další informace a příklady naleznete v tématu System.Threading.Timer.

System.Timers.Timer – třída

Dalším časovačem, který lze použít v prostředí s více vlákny, je System.Timers.Timer , že ve výchozím nastavení vyvolá událost ve vlákně ThreadPool .

Při vytváření objektu System.Timers.Timer můžete určit časový interval, ve kterém se má Elapsed vyvolat událost. Enabled Pomocí vlastnosti můžete určit, jestli má časovač vyvolat Elapsed událost. Pokud potřebujete, Elapsed aby byla událost vyvolána pouze jednou po uplynutí zadaného intervalu AutoReset , nastavte hodnotu false. Výchozí hodnota AutoReset vlastnosti je true, což znamená, že Elapsed událost je pravidelně vyvolána v intervalu definovaném Interval vlastností.

Další informace a příklady naleznete v tématu System.Timers.Timer.

Třída System.Threading.PeriodicTimer

Třída System.Threading.PeriodicTimer umožňuje očekávat jednotlivé ticky zadaného intervalu, provádění práce po volání PeriodicTimer.WaitForNextTickAsync.

Při vytváření objektu System.Threading.PeriodicTimer zadáte TimeSpan , který určuje dobu mezi jednotlivými záškrty časovače. Místo předání zpětného volání nebo nastavení obslužné rutiny události jako v předchozích třídách časovače provedete práci přímo v oboru a čekáte WaitForNextTickAsync na přechod časovače podle zadaného intervalu.

Metoda WaitForNextTickAsync vrátí ValueTask<bool>; true po úspěšném spuštění časovače a false kdy časovač byl zrušen voláním PeriodicTimer.Dispose. WaitForNextTickAsync volitelně přijímá možnost CancellationToken, která má za TaskCanceledException následek, kdy bylo požadováno zrušení.

Další informace najdete na webu System.Threading.PeriodicTimer.

Viz také