Timer Třída

Definice

Poskytuje mechanismus pro spuštění metody ve vlákně fondu vláken v určených intervalech.Provides a mechanism for executing a method on a thread pool thread at specified intervals. Tuto třídu nelze zdědit.This class cannot be inherited.

public ref class Timer sealed : MarshalByRefObject, IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Timer : MarshalByRefObject, IDisposable
type Timer = class
    inherit MarshalByRefObject
    interface IDisposable
Public NotInheritable Class Timer
Inherits MarshalByRefObject
Implements IDisposable
Dědičnost
Atributy
Implementuje

Příklady

Následující příklad definuje třídu StatusChecker, která obsahuje metodu CheckStatus, jejíž signatura je shodná s delegátem TimerCallback.The following example defines a StatusChecker class that includes a CheckStatus method whose signature is the same as the TimerCallback delegate. Argument state metody CheckStatus je objekt AutoResetEvent, který slouží k synchronizaci vlákna aplikace a vlákna fondu vláken, které spouští delegáta zpětného volání.The state argument of the CheckStatus method is an AutoResetEvent object that is used to synchronize the application thread and the thread pool thread that executes the callback delegate. Třída StatusChecker obsahuje také dvě proměnné stavu:The StatusChecker class also includes two state variables:

invokeCount
Určuje, kolikrát byla metoda zpětného volání vyvolána.Indicates the number of times the callback method has been invoked.

maxCount
Určuje maximální počet pokusů, kolikrát by měla být vyvolána metoda zpětného volání.Determines the maximum number of times the callback method should be invoked.

Vlákno aplikace vytvoří časovač, který počká jednu sekundu a pak spustí metodu CheckStatus zpětného volání každých 250 milisekund.The application thread creates the timer, which waits one second and then executes the CheckStatus callback method every 250 milliseconds. Vlákno aplikace pak zablokuje, dokud se nesignalizuje objekt AutoResetEvent.The application thread then blocks until the AutoResetEvent object is signaled. Pokud se metoda CheckStatus zpětného volání spustí maxCount časy, volá metodu AutoResetEvent.Set pro nastavení stavu objektu AutoResetEvent k signalizaci.When the CheckStatus callback method executes maxCount times, it calls the AutoResetEvent.Set method to set the state of the AutoResetEvent object to signaled. Při prvním spuštění volá vlákno aplikace metodu Change(Int32, Int32), aby se metoda zpětného volání nyní vyvolala každou polovinu sekundy.The first time this happens, the application thread calls the Change(Int32, Int32) method so that the callback method now executes every half second. Jakmile znovu dojde k zablokování objektu AutoResetEvent.It once again blocks until the AutoResetEvent object is signaled. Pokud k tomu dojde, je časovač zničen voláním jeho Dispose metody a aplikace se ukončí.When this happens, the timer is destroyed by calling its Dispose method, and the application terminates.

using namespace System;
using namespace System::Threading;

ref class StatusChecker
{
private:
    int invokeCount, maxCount;

public:
    StatusChecker(int count)
    {
        invokeCount  = 0;
        maxCount = count;
    }

    // This method is called by the timer delegate.
    void CheckStatus(Object^ stateInfo)
    {
        AutoResetEvent^ autoEvent = dynamic_cast<AutoResetEvent^>(stateInfo);
        Console::WriteLine("{0:h:mm:ss.fff} Checking status {1,2}.",
                           DateTime::Now, ++invokeCount);

        if (invokeCount == maxCount) {
            // Reset the counter and signal the waiting thread.
            invokeCount  = 0;
            autoEvent->Set();
        }
    }
};

ref class TimerExample
{
public:
    static void Main()
    {
        // Create an AutoResetEvent to signal the timeout threshold in the
        // timer callback has been reached.
        AutoResetEvent^ autoEvent = gcnew AutoResetEvent(false);

        StatusChecker^ statusChecker = gcnew StatusChecker(10);

        // Create a delegate that invokes methods for the timer.
        TimerCallback^ tcb =
           gcnew TimerCallback(statusChecker, &StatusChecker::CheckStatus);

        // Create a timer that invokes CheckStatus after one second, 
        // and every 1/4 second thereafter.
        Console::WriteLine("{0:h:mm:ss.fff} Creating timer.\n",
                           DateTime::Now);
        Timer^ stateTimer = gcnew Timer(tcb, autoEvent, 1000, 250);

        // When autoEvent signals, change the period to every half second.
        autoEvent->WaitOne(5000, false);
        stateTimer->Change(0, 500);
        Console::WriteLine("\nChanging period to .5 seconds.\n");

        // When autoEvent signals the second time, dispose of the timer.
        autoEvent->WaitOne(5000, false);
        stateTimer->~Timer();
        Console::WriteLine("\nDestroying timer.");
    }
};

int main()
{
    TimerExample::Main();
}
// The example displays output like the following:
//       11:59:54.202 Creating timer.
//       
//       11:59:55.217 Checking status  1.
//       11:59:55.466 Checking status  2.
//       11:59:55.716 Checking status  3.
//       11:59:55.968 Checking status  4.
//       11:59:56.218 Checking status  5.
//       11:59:56.470 Checking status  6.
//       11:59:56.722 Checking status  7.
//       11:59:56.972 Checking status  8.
//       11:59:57.223 Checking status  9.
//       11:59:57.473 Checking status 10.
//       
//       Changing period to .5 seconds.
//       
//       11:59:57.474 Checking status  1.
//       11:59:57.976 Checking status  2.
//       11:59:58.476 Checking status  3.
//       11:59:58.977 Checking status  4.
//       11:59:59.477 Checking status  5.
//       11:59:59.977 Checking status  6.
//       12:00:00.478 Checking status  7.
//       12:00:00.980 Checking status  8.
//       12:00:01.481 Checking status  9.
//       12:00:01.981 Checking status 10.
//       
//       Destroying timer.
using System;
using System.Threading;

class TimerExample
{
    static void Main()
    {
        // Create an AutoResetEvent to signal the timeout threshold in the
        // timer callback has been reached.
        var autoEvent = new AutoResetEvent(false);
        
        var statusChecker = new StatusChecker(10);

        // Create a timer that invokes CheckStatus after one second, 
        // and every 1/4 second thereafter.
        Console.WriteLine("{0:h:mm:ss.fff} Creating timer.\n", 
                          DateTime.Now);
        var stateTimer = new Timer(statusChecker.CheckStatus, 
                                   autoEvent, 1000, 250);

        // When autoEvent signals, change the period to every half second.
        autoEvent.WaitOne();
        stateTimer.Change(0, 500);
        Console.WriteLine("\nChanging period to .5 seconds.\n");

        // When autoEvent signals the second time, dispose of the timer.
        autoEvent.WaitOne();
        stateTimer.Dispose();
        Console.WriteLine("\nDestroying timer.");
    }
}

class StatusChecker
{
    private int invokeCount;
    private int  maxCount;

    public StatusChecker(int count)
    {
        invokeCount  = 0;
        maxCount = count;
    }

    // This method is called by the timer delegate.
    public void CheckStatus(Object stateInfo)
    {
        AutoResetEvent autoEvent = (AutoResetEvent)stateInfo;
        Console.WriteLine("{0} Checking status {1,2}.", 
            DateTime.Now.ToString("h:mm:ss.fff"), 
            (++invokeCount).ToString());

        if(invokeCount == maxCount)
        {
            // Reset the counter and signal the waiting thread.
            invokeCount = 0;
            autoEvent.Set();
        }
    }
}
// The example displays output like the following:
//       11:59:54.202 Creating timer.
//       
//       11:59:55.217 Checking status  1.
//       11:59:55.466 Checking status  2.
//       11:59:55.716 Checking status  3.
//       11:59:55.968 Checking status  4.
//       11:59:56.218 Checking status  5.
//       11:59:56.470 Checking status  6.
//       11:59:56.722 Checking status  7.
//       11:59:56.972 Checking status  8.
//       11:59:57.223 Checking status  9.
//       11:59:57.473 Checking status 10.
//       
//       Changing period to .5 seconds.
//       
//       11:59:57.474 Checking status  1.
//       11:59:57.976 Checking status  2.
//       11:59:58.476 Checking status  3.
//       11:59:58.977 Checking status  4.
//       11:59:59.477 Checking status  5.
//       11:59:59.977 Checking status  6.
//       12:00:00.478 Checking status  7.
//       12:00:00.980 Checking status  8.
//       12:00:01.481 Checking status  9.
//       12:00:01.981 Checking status 10.
//       
//       Destroying timer.
Imports System.Threading

Public Module Example
    Public Sub Main()
        ' Use an AutoResetEvent to signal the timeout threshold in the
        ' timer callback has been reached.
        Dim autoEvent As New AutoResetEvent(False)

        Dim statusChecker As New StatusChecker(10)

        ' Create a timer that invokes CheckStatus after one second, 
        ' and every 1/4 second thereafter.
        Console.WriteLine("{0:h:mm:ss.fff} Creating timer." & vbCrLf, 
                          DateTime.Now)
        Dim stateTimer As New Timer(AddressOf statusChecker.CheckStatus, 
                                    autoEvent, 1000, 250)

        ' When autoEvent signals, change the period to every half second.
        autoEvent.WaitOne()
        stateTimer.Change(0, 500)
        Console.WriteLine(vbCrLf & "Changing period to .5 seconds." & vbCrLf)

        ' When autoEvent signals the second time, dispose of the timer.
        autoEvent.WaitOne()
        stateTimer.Dispose()
        Console.WriteLine(vbCrLf & "Destroying timer.")
    End Sub
End Module

Public Class StatusChecker
    Dim invokeCount, maxCount As Integer 

    Sub New(count As Integer)
        invokeCount  = 0
        maxCount = count
    End Sub

    ' The timer callback method.
    Sub CheckStatus(stateInfo As Object)
        Dim autoEvent As AutoResetEvent = DirectCast(stateInfo, AutoResetEvent)
        invokeCount += 1
        Console.WriteLine("{0:h:mm:ss.fff} Checking status {1,2}.", 
                          DateTime.Now, invokeCount)
        If invokeCount = maxCount Then
            ' Reset the counter and signal the waiting thread.
            invokeCount = 0
            autoEvent.Set()
        End If
    End Sub
End Class
' The example displays output like the following:
'       11:59:54.202 Creating timer.
'       
'       11:59:55.217 Checking status  1.
'       11:59:55.466 Checking status  2.
'       11:59:55.716 Checking status  3.
'       11:59:55.968 Checking status  4.
'       11:59:56.218 Checking status  5.
'       11:59:56.470 Checking status  6.
'       11:59:56.722 Checking status  7.
'       11:59:56.972 Checking status  8.
'       11:59:57.223 Checking status  9.
'       11:59:57.473 Checking status 10.
'       
'       Changing period to .5 seconds.
'       
'       11:59:57.474 Checking status  1.
'       11:59:57.976 Checking status  2.
'       11:59:58.476 Checking status  3.
'       11:59:58.977 Checking status  4.
'       11:59:59.477 Checking status  5.
'       11:59:59.977 Checking status  6.
'       12:00:00.478 Checking status  7.
'       12:00:00.980 Checking status  8.
'       12:00:01.481 Checking status  9.
'       12:00:01.981 Checking status 10.
'       
'       Destroying timer.

Poznámky

Pomocí delegáta TimerCallback určete metodu, kterou má Timer provést.Use a TimerCallback delegate to specify the method you want the Timer to execute. Signatura TimerCallback delegáta je:The signature of the TimerCallback delegate is:

void TimerCallback(Object state)  
void TimerCallback(Object state)  
Sub TimerCallback(state As Object)  

Delegát časovače je určen při sestavení časovače a nemůže být změněn.The timer delegate is specified when the timer is constructed, and cannot be changed. Metoda se nespustí ve vlákně, které vytvořilo časovač; spouští se v ThreadPool vlákně dodaném systémem.The method does not execute on the thread that created the timer; it executes on a ThreadPool thread supplied by the system.

Tip

Rozhraní .NET zahrnuje čtyři třídy s názvem Timer, z nichž každá nabízí různé funkce:.NET includes four classes named Timer, each of which offers different functionality:

  • System.Timers.Timer, která aktivuje událost a spustí kód v jednom nebo více jímka události v pravidelných intervalech.System.Timers.Timer, which fires an event and executes the code in one or more event sinks at regular intervals. Třída je určena pro použití jako součást serveru nebo služby ve vícevláknovém prostředí; nemá žádné uživatelské rozhraní a není zobrazená za běhu.The class is intended for use as a server-based or service component in a multithreaded environment; it has no user interface and is not visible at runtime.
  • System.Threading.Timer, která spouští jednu metodu zpětného volání ve vlákně fondu vláken v pravidelných intervalech.System.Threading.Timer, which executes a single callback method on a thread pool thread at regular intervals. Metoda zpětného volání je definována při vytváření instance časovače a nelze ji změnit.The callback method is defined when the timer is instantiated and cannot be changed. Podobně jako třída System.Timers.Timer, je tato třída určena pro použití jako součást serveru nebo služby ve vícevláknovém prostředí; nemá žádné uživatelské rozhraní a není zobrazená za běhu.Like the System.Timers.Timer class, this class is intended for use as a server-based or service component in a multithreaded environment; it has no user interface and is not visible at runtime.
  • System.Windows.Forms.Timer (pouze .NET Framework), model Windows Forms komponenta, která aktivuje událost a spustí kód v jednom nebo více jímka události v pravidelných intervalech.System.Windows.Forms.Timer (.NET Framework only), a Windows Forms component that fires an event and executes the code in one or more event sinks at regular intervals. Komponenta nemá žádné uživatelské rozhraní a je určena pro použití v prostředí s jedním vláknem; spouští se ve vlákně uživatelského rozhraní.The component has no user interface and is designed for use in a single-threaded environment; it executes on the UI thread.
  • System.Web.UI.Timer (pouze .NET Framework), komponenta ASP.NET, která provádí asynchronní nebo synchronní zpětné volání webových stránek v pravidelných intervalech.System.Web.UI.Timer (.NET Framework only), an ASP.NET component that performs asynchronous or synchronous web page postbacks at a regular interval.

Při vytváření časovače můžete zadat dobu, po kterou se má čekat před prvním spuštěním metody (termín splnění), a určit dobu, po kterou se má čekat mezi následnými provedeními (period).When you create a timer, you can specify an amount of time to wait before the first execution of the method (due time), and an amount of time to wait between subsequent executions (period). Třída Timer má stejné řešení jako systémové hodiny.The Timer class has the same resolution as the system clock. To znamená, že pokud je období kratší než rozlišení systémových hodin, bude delegát TimerCallback spuštěn v intervalech definovaných řešením systémových hodin, což je přibližně 15 milisekund v systémech Windows 7 a Windows 8.This means that if the period is less than the resolution of the system clock, the TimerCallback delegate will execute at intervals defined by the resolution of the system clock, which is approximately 15 milliseconds on Windows 7 and Windows 8 systems. Můžete změnit čas a období splatnosti nebo zakázat časovač pomocí metody Change.You can change the due time and period, or disable the timer, by using the Change method.

Poznámka

Pokud používáte Timer, musíte na něj zachovat odkaz.As long as you are using a Timer, you must keep a reference to it. Stejně jako u všech spravovaných objektů podléhá Timer uvolňování paměti, když na něj neexistují žádné odkazy.As with any managed object, a Timer is subject to garbage collection when there are no references to it. Fakt, že je stále aktivní Timer, nebrání jeho shromažďování.The fact that a Timer is still active does not prevent it from being collected.

Pokud již časovač nepotřebujete, použijte metodu Dispose pro uvolnění prostředků držených časovačem.When a timer is no longer needed, use the Dispose method to free the resources held by the timer. Všimněte si, že zpětná volání mohou nastat po volání přetížení metody Dispose(), protože časovače zařadí zpětná volání do fronty pro spuštění vlákny fondu vláken.Note that callbacks can occur after the Dispose() method overload has been called, because the timer queues callbacks for execution by thread pool threads. Přetížení metody Dispose(WaitHandle) můžete použít k čekání na dokončení všech zpětných volání.You can use the Dispose(WaitHandle) method overload to wait until all callbacks have completed.

Metodu zpětného volání spuštěnou časovačem by měla být znovu vybrána, protože je volána v ThreadPool vláknech.The callback method executed by the timer should be reentrant, because it is called on ThreadPool threads. Zpětné volání lze spustit současně ve dvou vláknech fondu vláken, je-li interval časovače kratší než čas potřebný ke spuštění zpětného volání, nebo pokud se všechny podprocesy fondu vláken používají a zpětné volání je vícekrát zařazeno do fronty.The callback can be executed simultaneously on two thread pool threads if the timer interval is less than the time required to execute the callback, or if all thread pool threads are in use and the callback is queued multiple times.

Poznámka

System.Threading.Timer je jednoduchý, odlehčený časovač, který používá metody zpětného volání a je obsluhován vlákny fondu vláken.System.Threading.Timer is a simple, lightweight timer that uses callback methods and is served by thread pool threads. Nedoporučuje se používat s model Windows Forms, protože zpětná volání se nevyskytují ve vláknu uživatelského rozhraní.It is not recommended for use with Windows Forms, because its callbacks do not occur on the user interface thread. System.Windows.Forms.Timer je lepší volbou pro použití s model Windows Forms.System.Windows.Forms.Timer is a better choice for use with Windows Forms. U funkce časovače založeného na serveru můžete zvážit použití System.Timers.Timer, které vyvolává události a má další funkce.For server-based timer functionality, you might consider using System.Timers.Timer, which raises events and has additional features.

Konstruktory

Timer(TimerCallback)

Inicializuje novou instanci třídy Timer s nekonečnou periodou a nekonečným časem, který používá nově vytvořený Timer objekt jako objekt State.Initializes a new instance of the Timer class with an infinite period and an infinite due time, using the newly created Timer object as the state object.

Timer(TimerCallback, Object, Int32, Int32)

Inicializuje novou instanci třídy Timer s použitím 32ého celého čísla se znaménkem, které určuje časový interval.Initializes a new instance of the Timer class, using a 32-bit signed integer to specify the time interval.

Timer(TimerCallback, Object, Int64, Int64)

Inicializuje novou instanci třídy Timer s použitím 64 celých čísel se znaménkem pro měření časových intervalů.Initializes a new instance of the Timer class, using 64-bit signed integers to measure time intervals.

Timer(TimerCallback, Object, TimeSpan, TimeSpan)

Inicializuje novou instanci třídy Timer pomocí hodnot TimeSpan pro měření časových intervalů.Initializes a new instance of the Timer class, using TimeSpan values to measure time intervals.

Timer(TimerCallback, Object, UInt32, UInt32)

Inicializuje novou instanci třídy Timer pomocí 32 celých čísel bez znaménka pro měření časových intervalů.Initializes a new instance of the Timer class, using 32-bit unsigned integers to measure time intervals.

Vlastnosti

ActiveCount

Získá počet časovačů, které jsou aktuálně aktivní.Gets the number of timers that are currently active. Aktivní časovač je zaregistrován tak, aby byl v budoucnu v budoucnosti a ještě nebyl zrušen.An active timer is registered to tick at some point in the future, and has not yet been canceled.

Metody

Change(Int32, Int32)

Změní čas spuštění a interval mezi voláními metod pro časovač, pomocí 32 celých čísel se znaménkem pro měření časových intervalů.Changes the start time and the interval between method invocations for a timer, using 32-bit signed integers to measure time intervals.

Change(Int64, Int64)

Změní čas spuštění a interval mezi voláními metod pro časovač, pomocí 64 celých čísel se znaménkem pro měření časových intervalů.Changes the start time and the interval between method invocations for a timer, using 64-bit signed integers to measure time intervals.

Change(TimeSpan, TimeSpan)

Změní čas spuštění a interval mezi voláními metod časovače pomocí TimeSpan hodnoty pro měření časových intervalů.Changes the start time and the interval between method invocations for a timer, using TimeSpan values to measure time intervals.

Change(UInt32, UInt32)

Změní čas spuštění a interval mezi voláními metod pro časovač, pomocí 32 celých čísel bez znaménka k měření časových intervalů.Changes the start time and the interval between method invocations for a timer, using 32-bit unsigned integers to measure time intervals.

CreateObjRef(Type)

Vytvoří objekt, který obsahuje všechny relevantní informace požadované pro vygenerování proxy serveru, který se používá ke komunikaci se vzdáleným objektem.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Zděděno od MarshalByRefObject)
Dispose()

Uvolní všechny prostředky používané aktuální instancí Timer.Releases all resources used by the current instance of Timer.

Dispose(WaitHandle)

Uvolní všechny prostředky používané aktuální instancí Timer a signalizuje, když byl časovač vyřazený.Releases all resources used by the current instance of Timer and signals when the timer has been disposed of.

DisposeAsync()

Uvolní všechny prostředky používané aktuální instancí Timer.Releases all resources used by the current instance of Timer.

Equals(Object)

Určuje, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Zděděno od Object)
Finalize()

Umožňuje objektu uvolnit prostředky a provést jiné operace čištění před tím, než se uvolní uvolňováním paměti.Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection.

GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Zděděno od Object)
GetLifetimeService()

Načte aktuální objekt služby životnosti, který řídí zásady životního cyklu pro tuto instanci.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Zděděno od MarshalByRefObject)
GetType()

Získá Type aktuální instance.Gets the Type of the current instance.

(Zděděno od Object)
InitializeLifetimeService()

Získá objekt služby životnosti, který řídí zásady životního cyklu pro tuto instanci.Obtains a lifetime service object to control the lifetime policy for this instance.

(Zděděno od MarshalByRefObject)
MemberwiseClone()

Vytvoří kopii aktuálního Objectbez podstruktury.Creates a shallow copy of the current Object.

(Zděděno od Object)
MemberwiseClone(Boolean)

Vytvoří kopii aktuálního objektu MarshalByRefObject bez podstruktury.Creates a shallow copy of the current MarshalByRefObject object.

(Zděděno od MarshalByRefObject)
ToString()

Vrací řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Zděděno od Object)

Platí pro

Bezpečný přístup z více vláken

Tento typ je bezpečný pro přístup z více vláken.This type is thread safe.

Viz také