Timer Konstruktorok

Definíció

Névtér:
System.Threading
Szerelvény:
mscorlib.dll
Szerelvény:
netstandard.dll
Szerelvények:
mscorlib.dll, System.Threading.Timer.dll
Szerelvény:
System.Threading.Timer.dll

Inicializálja a Timer osztály új példányát.

Túlterhelések

Name Description
Timer(TimerCallback)

Inicializálja az Timer osztály egy új példányát egy végtelen időszakkal és egy végtelen határidővel, az újonnan létrehozott Timer objektumot használva állapotobjektumként.
Timer(TimerCallback, Object, Int32, Int32)

Inicializálja az Timer osztály új példányát egy 32 bites aláírt egész számmal az időintervallum megadásához.
Timer(TimerCallback, Object, Int64, Int64)

Inicializálja az Timer osztály új példányát 64 bites aláírt egész számokkal az időintervallumok méréséhez.
Timer(TimerCallback, Object, TimeSpan, TimeSpan)

Inicializálja az Timer osztály új példányát az időintervallumok mérésére használt TimeSpan értékekkel.
Timer(TimerCallback, Object, UInt32, UInt32)

Inicializálja az Timer osztály új példányát, 32 bites aláíratlan egész számokkal az időintervallumok méréséhez.

Timer(TimerCallback)

Inicializálja az Timer osztály egy új példányát egy végtelen időszakkal és egy végtelen határidővel, az újonnan létrehozott Timer objektumot használva állapotobjektumként.

public:
 Timer(System::Threading::TimerCallback ^ callback);
public Timer(System.Threading.TimerCallback callback);
new System.Threading.Timer : System.Threading.TimerCallback -> System.Threading.Timer
Public Sub New (callback As TimerCallback)

Paraméterek

callback
TimerCallback

A TimerCallback végrehajtandó metódust képviselő meghatalmazott.

Példák

Az alábbi példakód egy új időzítőt hoz létre, amely magát az időzítőt használja állapotobjektumként. A Change metódus az időzítő elindítására szolgál. Az időzítő visszahívásakor az állapotobjektumot használja az időzítő kikapcsolásához.

using System;
using System.Threading;

public class Example
{
    public static void Main()
    {
        // Create an instance of the Example class, and start two
        // timers.
        Example ex = new Example();
        ex.StartTimer(2000);
        ex.StartTimer(1000);

        Console.WriteLine("Press Enter to end the program.");
        Console.ReadLine();
    }

    public void StartTimer(int dueTime)
    {
        Timer t = new Timer(new TimerCallback(TimerProc));
        t.Change(dueTime, 0);
    }

    private void TimerProc(object state)
    {
        // The state object is the Timer object.
        Timer t = (Timer) state;
        t.Dispose();
        Console.WriteLine("The timer callback executes.");
    }
}

Imports System.Threading

Public Class Example
    Public Shared Sub Main()
        ' Create an instance of the Example class, and start two
        ' timers.
        Dim ex As New Example()
        ex.StartTimer(2000)
        ex.StartTimer(1000)

        Console.WriteLine("Press Enter to end the program.")
        Console.ReadLine()
    End Sub

    Public Sub StartTimer(ByVal dueTime As Integer)
        Dim t As New Timer(AddressOf TimerProc)
        t.Change(dueTime, 0)
    End Sub

    Private Sub TimerProc(ByVal state As Object)
        ' The state object is the Timer object.
        Dim t As Timer = CType(state, Timer)
        t.Dispose()
        Console.WriteLine("The timer callback executes.")
    End Sub
End Class

Megjegyzések

Hívja meg ezt a konstruktort, ha magát az Timer objektumot szeretné állapotobjektumként használni. Az időzítő létrehozása után a Change metódus használatával állítsa be az időközt és a határidőt.

Ez a konstruktor az első visszahívás előtt végtelen határidőt és a visszahívások közötti végtelen időközt adja meg annak érdekében, hogy az első visszahívás ne fordulhasson elő, mielőtt az Timer objektum hozzá lett rendelve az állapotobjektumhoz.

A megadott metódusnak callback újra kell entrantnak lennie, mert a rendszer meghívja a szálakon ThreadPool . A metódus egyszerre két szálkészlet-szálon is végrehajtható, ha az időzítőintervallum kisebb, mint a metódus végrehajtásához szükséges idő, vagy ha az összes szálkészlet-szál használatban van, és a metódus többször is várólistára kerül.

A következőre érvényes:

Timer(TimerCallback, Object, Int32, Int32)

Inicializálja az Timer osztály új példányát egy 32 bites aláírt egész számmal az időintervallum megadásához.

public:
 Timer(System::Threading::TimerCallback ^ callback, System::Object ^ state, int dueTime, int period);
public Timer(System.Threading.TimerCallback callback, object state, int dueTime, int period);
new System.Threading.Timer : System.Threading.TimerCallback * obj * int * int -> System.Threading.Timer
Public Sub New (callback As TimerCallback, state As Object, dueTime As Integer, period As Integer)

Paraméterek

callback
TimerCallback

A TimerCallback végrehajtandó metódust képviselő meghatalmazott.

state
Object

Olyan objektum, amely a visszahívási módszer által használandó információkat tartalmazza, vagy null.

dueTime
Int32

A meghívás előtti callback késleltetési idő ezredmásodpercben. Adja meg Infinite , hogy az időzítő ne induljon el. Adja meg a nullát (0) az időzítő azonnali indításához.

period
Int32

A meghívások callbackközötti időintervallum ezredmásodpercben. Adja meg Infinite az időszakos jelzés letiltását.

Kivételek

ArgumentOutOfRangeException

A dueTime vagy period paraméter negatív, és nem egyenlő .Infinite

ArgumentNullException

A callback paraméter a következő null: .

Példák

Az alábbi példakód bemutatja, hogyan hozhat létre delegáltat TimerCallback , és inicializálhatja az osztály új példányát 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.

Megjegyzések

A paraméter által megadott delegáltat az callback eltelt idő után dueTime egyszer hívja meg a függvény, majd ezt követően minden alkalommal, amikor az period időintervallum eltelik.

Ha dueTime nulla (0), callback a függvény azonnal meghívja. Ha dueTime igen Timeout.Infinite, callback akkor a rendszer nem hívja meg; az időzítő le van tiltva, de a metódus meghívásával Change újra engedélyezhető.

Mivel a Timer osztály felbontása megegyezik a rendszerórával, ami körülbelül 15 ezredmásodperc Windows 7 és Windows 8 rendszereken, a callback delegált a rendszeróra felbontása által meghatározott időközönként hajt végre, ha period kisebb, mint a rendszeróra felbontása. Ha period nulla (0) vagy Timeout.InfinitedueTime nem Timeout.Infinite, callback akkor a rendszer egyszer hívja meg; az időzítő rendszeres viselkedése le van tiltva, de a metódussal Change újra engedélyezhető.

Note

A használt rendszeróra megegyezik a GetTickCount által használt órával, amelyet a timeBeginPeriod és a timeEndPeriod módosításai nem befolyásolnak.

A megadott metódusnak callback újra kell entrantnak lennie, mert a rendszer meghívja a szálakon ThreadPool . A metódus egyszerre két szálkészlet-szálon is végrehajtható, ha az időzítőintervallum kisebb, mint a metódus végrehajtásához szükséges idő, vagy ha az összes szálkészlet-szál használatban van, és a metódus többször is várólistára kerül.

Lásd még

A következőre érvényes:

Timer(TimerCallback, Object, Int64, Int64)

Inicializálja az Timer osztály új példányát 64 bites aláírt egész számokkal az időintervallumok méréséhez.

public:
 Timer(System::Threading::TimerCallback ^ callback, System::Object ^ state, long dueTime, long period);
public Timer(System.Threading.TimerCallback callback, object state, long dueTime, long period);
new System.Threading.Timer : System.Threading.TimerCallback * obj * int64 * int64 -> System.Threading.Timer
Public Sub New (callback As TimerCallback, state As Object, dueTime As Long, period As Long)

Paraméterek

callback
TimerCallback

A TimerCallback végrehajtandó metódust képviselő meghatalmazott.

state
Object

Olyan objektum, amely a visszahívási módszer által használandó információkat tartalmazza, vagy null.

dueTime
Int64

A meghívás előtti callback késleltetési idő ezredmásodpercben. Adja meg Infinite , hogy az időzítő ne induljon el. Adja meg a nullát (0) az időzítő azonnali indításához.

period
Int64

A meghívások callbackközötti időintervallum ezredmásodpercben. Adja meg Infinite az időszakos jelzés letiltását.

Kivételek

ArgumentOutOfRangeException

A dueTime vagy period paraméter negatív, és nem egyenlő .Infinite

NotSupportedException

A dueTime vagy period paraméter nagyobb, mint 4294967294.

Megjegyzések

A paraméter által megadott delegáltat az callback eltelt idő után dueTime egyszer hívja meg a függvény, majd ezt követően minden alkalommal, amikor az period időintervallum eltelik.

Ha dueTime nulla (0), callback a függvény azonnal meghívja. Ha dueTime igen Timeout.Infinite, callback akkor a rendszer nem hívja meg; az időzítő le van tiltva, de a metódus meghívásával Change újra engedélyezhető.

Mivel a Timer osztály felbontása megegyezik a rendszerórával, ami körülbelül 15 ezredmásodperc Windows 7 és Windows 8 rendszereken, a callback delegált a rendszeróra felbontása által meghatározott időközönként hajt végre, ha period kisebb, mint a rendszeróra felbontása.

Ha period nulla (0) vagy Timeout.InfinitedueTime nem Timeout.Infinite, callback akkor a rendszer egyszer hívja meg; az időzítő rendszeres viselkedése le van tiltva, de a metódussal Change újra engedélyezhető.

Note

A használt rendszeróra megegyezik a GetTickCount által használt órával, amelyet a timeBeginPeriod és a timeEndPeriod módosításai nem befolyásolnak.

A megadott metódusnak callback újra kell entrantnak lennie, mert a rendszer meghívja a szálakon ThreadPool . A metódus egyszerre két szálkészlet-szálon is végrehajtható, ha az időzítőintervallum kisebb, mint a metódus végrehajtásához szükséges idő, vagy ha az összes szálkészlet-szál használatban van, és a metódus többször is várólistára kerül.

Lásd még

A következőre érvényes:

Timer(TimerCallback, Object, TimeSpan, TimeSpan)

Inicializálja az Timer osztály új példányát az időintervallumok mérésére használt TimeSpan értékekkel.

public:
 Timer(System::Threading::TimerCallback ^ callback, System::Object ^ state, TimeSpan dueTime, TimeSpan period);
public Timer(System.Threading.TimerCallback callback, object state, TimeSpan dueTime, TimeSpan period);
new System.Threading.Timer : System.Threading.TimerCallback * obj * TimeSpan * TimeSpan -> System.Threading.Timer
Public Sub New (callback As TimerCallback, state As Object, dueTime As TimeSpan, period As TimeSpan)

Paraméterek

callback
TimerCallback

A végrehajtandó metódust képviselő meghatalmazott.

state
Object

Olyan objektum, amely a visszahívási módszer által használandó információkat tartalmazza, vagy null.

dueTime
TimeSpan

Az a késleltetési idő, amely a callback meghívás előtt eltelik. Adja meg InfiniteTimeSpan , hogy az időzítő ne induljon el. Adja meg Zero az időzítő azonnali indítását.

period
TimeSpan

A meghívások callbackközötti időintervallum. Adja meg InfiniteTimeSpan az időszakos jelzés letiltását.

Kivételek

ArgumentOutOfRangeException

Az ezredmásodpercek száma negatív dueTime vagy period negatív, és nem egyenlő Infinite, vagy nagyobb, mint az Int32.MaxValue.

ArgumentNullException

A callback paraméter a következő null: .

Példák

Az alábbi példakód bemutatja, hogyan hozhat létre delegáltat TimerCallback , és inicializálhatja az osztály új példányát Timer .

using System;
using System.Threading;

class TimerExample
{
    static void Main()
    {
        AutoResetEvent autoEvent     = new AutoResetEvent(false);
        StatusChecker  statusChecker = new StatusChecker(10);

        // Create the delegate that invokes methods for the timer.
        TimerCallback timerDelegate = 
            new TimerCallback(statusChecker.CheckStatus);

        TimeSpan delayTime = new TimeSpan(0, 0, 1);
        TimeSpan intervalTime = new TimeSpan(0, 0, 0, 0, 250);

        // Create a timer that signals the delegate to invoke 
        // CheckStatus after one second, and every 1/4 second 
        // thereafter.
        Console.WriteLine("{0} Creating timer.\n", 
            DateTime.Now.ToString("h:mm:ss.fff"));
        Timer stateTimer = new Timer(
            timerDelegate, autoEvent, delayTime, intervalTime);

        // When autoEvent signals, change the period to every 
        // 1/2 second.
        autoEvent.WaitOne(5000, false);
        stateTimer.Change(new TimeSpan(0), 
            intervalTime + intervalTime);
        Console.WriteLine("\nChanging period.\n");

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

class StatusChecker
{
    int invokeCount, 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 Main.
            invokeCount  = 0;
            autoEvent.Set();
        }
    }
}

Imports System.Threading

Public Class TimerExample

    <MTAThread> _
    Shared Sub Main()
    
        Dim autoEvent As New AutoResetEvent(False)
        Dim statusChecker As New StatusChecker(10)

        ' Create the delegate that invokes methods for the timer.
        Dim timerDelegate As TimerCallback = _
            AddressOf statusChecker.CheckStatus

        Dim delayTime As New TimeSpan(0, 0, 1)
        Dim intervalTime As New TimeSpan(0, 0, 0, 0, 250)

        ' Create a timer that signals the delegate to invoke 
        ' CheckStatus after one second, and every 1/4 second 
        ' thereafter.
        Console.WriteLine("{0} Creating timer." & vbCrLf, _
            DateTime.Now.ToString("h:mm:ss.fff"))
        Dim stateTimer As Timer = New Timer( _
            timerDelegate, autoEvent, delayTime, intervalTime)

        ' When autoEvent signals, change the period to every 
        ' 1/2 second.
        autoEvent.WaitOne(5000, False)
        stateTimer.Change( _
            new TimeSpan(0), intervalTime.Add(intervalTime))
        Console.WriteLine(vbCrLf & "Changing period." & vbCrLf)

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

Public Class StatusChecker

    Dim invokeCount, maxCount As Integer 

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

    ' This method is called by the timer delegate.
    Sub CheckStatus(stateInfo As Object)
        Dim autoEvent As AutoResetEvent = _
            DirectCast(stateInfo, AutoResetEvent)
        invokeCount += 1
        Console.WriteLine("{0} Checking status {1,2}.", _
            DateTime.Now.ToString("h:mm:ss.fff"), _
            invokeCount.ToString())

        If invokeCount = maxCount Then
        
            ' Reset the counter and signal to stop the timer.
            invokeCount  = 0
            autoEvent.Set()
        End If
    End Sub

End Class

Megjegyzések

A paraméter által megadott delegáltat az callback eltelt idő után dueTime egyszer hívja meg a függvény, majd ezt követően minden alkalommal, amikor az period időintervallum eltelik.

Ha dueTime nulla (0), callback a függvény azonnal meghívja. Ha dueTime negatív (-1) ezredmásodperc, callback akkor a rendszer nem hívja meg; az időzítő le van tiltva, de a metódus meghívásával Change újra engedélyezhető.

Mivel a Timer osztály felbontása megegyezik a rendszerórával, ami körülbelül 15 ezredmásodperc Windows 7 és Windows 8 rendszereken, a callback delegált a rendszeróra felbontása által meghatározott időközönként hajt végre, ha period kisebb, mint a rendszeróra felbontása. Ha period nulla (0) vagy negatív (-1) ezredmásodperc, és dueTime pozitív, callback akkor a rendszer egyszer hívja meg; az időzítő rendszeres viselkedése le van tiltva, de a metódussal Change újra engedélyezhető.

Note

A használt rendszeróra megegyezik a GetTickCount által használt órával, amelyet a timeBeginPeriod és a timeEndPeriod módosításai nem befolyásolnak.

A megadott metódusnak callback újra kell entrantnak lennie, mert a rendszer meghívja a szálakon ThreadPool . A metódus egyszerre két szálkészlet-szálon is végrehajtható, ha az időzítőintervallum kisebb, mint a metódus végrehajtásához szükséges idő, vagy ha az összes szálkészlet-szál használatban van, és a metódus többször is várólistára kerül.

Lásd még

A következőre érvényes:

Timer(TimerCallback, Object, UInt32, UInt32)

Fontos

Ez az API nem CLS-kompatibilis.

Inicializálja az Timer osztály új példányát, 32 bites aláíratlan egész számokkal az időintervallumok méréséhez.

public:
 Timer(System::Threading::TimerCallback ^ callback, System::Object ^ state, System::UInt32 dueTime, System::UInt32 period);
[System.CLSCompliant(false)]
public Timer(System.Threading.TimerCallback callback, object state, uint dueTime, uint period);
[<System.CLSCompliant(false)>]
new System.Threading.Timer : System.Threading.TimerCallback * obj * uint32 * uint32 -> System.Threading.Timer
Public Sub New (callback As TimerCallback, state As Object, dueTime As UInteger, period As UInteger)

Paraméterek

callback
TimerCallback

A végrehajtandó metódust képviselő meghatalmazott.

state
Object

Olyan objektum, amely a visszahívási módszer által használandó információkat tartalmazza, vagy null.

dueTime
UInt32

A meghívás előtti callback késleltetési idő ezredmásodpercben. Adja meg Infinite , hogy az időzítő ne induljon el. Adja meg a nullát (0) az időzítő azonnali indításához.

period
UInt32

A meghívások callbackközötti időintervallum ezredmásodpercben. Adja meg Infinite az időszakos jelzés letiltását.

Attribútumok
CLSCompliantAttribute

Kivételek

ArgumentOutOfRangeException

A dueTime vagy period paraméter negatív, és nem egyenlő .Infinite

ArgumentNullException

A callback paraméter a következő null: .

Megjegyzések

A paraméter által megadott delegáltat az callback eltelt idő után dueTime egyszer hívja meg a függvény, majd ezt követően minden alkalommal, amikor az period időintervallum eltelik.

Ha dueTime nulla (0), callback a függvény azonnal meghívja. Ha dueTime igen Timeout.Infinite, callback akkor a rendszer nem hívja meg; az időzítő le van tiltva, de a metódus meghívásával Change újra engedélyezhető.

Mivel a Timer osztály felbontása megegyezik a rendszerórával, ami körülbelül 15 ezredmásodperc Windows 7 és Windows 8 rendszereken, a callback delegált a rendszeróra felbontása által meghatározott időközönként hajt végre, ha period kisebb, mint a rendszeróra felbontása. Ha period nulla (0) vagy Timeout.InfinitedueTime nem Timeout.Infinite, callback akkor a rendszer egyszer hívja meg; az időzítő rendszeres viselkedése le van tiltva, de a metódussal Change újra engedélyezhető.

Note

A használt rendszeróra megegyezik a GetTickCount által használt órával, amelyet a timeBeginPeriod és a timeEndPeriod módosításai nem befolyásolnak.

A megadott metódusnak callback újra kell entrantnak lennie, mert a rendszer meghívja a szálakon ThreadPool . A metódus egyszerre két szálkészlet-szálon is végrehajtható, ha az időzítőintervallum kisebb, mint a metódus végrehajtásához szükséges idő, vagy ha az összes szálkészlet-szál használatban van, és a metódus többször is várólistára kerül.

Lásd még

A következőre érvényes: