Timer Classe

Définition

public ref class Timer sealed : IDisposable

public ref class Timer sealed : MarshalByRefObject, IDisposable

public ref class Timer sealed : MarshalByRefObject, IAsyncDisposable, IDisposable

[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Timer : IDisposable

public sealed class Timer : MarshalByRefObject, IDisposable

[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Timer : MarshalByRefObject, IDisposable

public sealed class Timer : MarshalByRefObject, IAsyncDisposable, IDisposable

[<System.Runtime.InteropServices.ComVisible(true)>]
type Timer = class
    interface IDisposable

type Timer = class
    inherit MarshalByRefObject
    interface IDisposable

[<System.Runtime.InteropServices.ComVisible(true)>]
type Timer = class
    inherit MarshalByRefObject
    interface IDisposable

type Timer = class
    inherit MarshalByRefObject
    interface IAsyncDisposable
    interface IDisposable

Public NotInheritable Class Timer
Implements IDisposable

Public NotInheritable Class Timer
Inherits MarshalByRefObject
Implements IDisposable

Public NotInheritable Class Timer
Inherits MarshalByRefObject
Implements IAsyncDisposable, IDisposable

Héritage

Object

Timer

Héritage

Object

MarshalByRefObject

Timer

Attributs

ComVisibleAttribute

Implémente

IDisposable IAsyncDisposable

Exemples

L’exemple suivant définit une StatusChecker classe qui inclut une CheckStatus méthode dont la signature est identique au TimerCallback délégué. L’argument state de la CheckStatus méthode est un AutoResetEvent objet utilisé pour synchroniser le thread d’application et le thread de pool de threads qui exécute le délégué de rappel. La StatusChecker classe inclut également deux variables d’état :

invokeCount
Indique le nombre de fois où la méthode de rappel a été appelée.

maxCount
Détermine le nombre maximal de fois où la méthode de rappel doit être appelée.

Le thread d’application crée le minuteur, qui attend une seconde, puis exécute la méthode de CheckStatus rappel toutes les 250 millisecondes. Le thread d’application bloque ensuite jusqu’à ce que l’objet AutoResetEvent soit signalé. Lorsque la méthode de CheckStatus rappel s’exécute maxCount plusieurs fois, elle appelle la AutoResetEvent.Set méthode pour définir l’état de l’objet AutoResetEvent à signaler. La première fois que cela se produit, le thread d’application appelle la Change(Int32, Int32) méthode afin que la méthode de rappel s’exécute désormais toutes les demi-secondes. Il bloque une fois de plus jusqu’à ce que l’objet AutoResetEvent soit signalé. Lorsque cela se produit, le minuteur est détruit en appelant sa Dispose méthode et l’application se termine.

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.

Remarques

Utilisez un TimerCallback délégué pour spécifier la méthode à Timer exécuter. La signature du TimerCallback délégué est la suivante :

void TimerCallback(Object state)

Sub TimerCallback(state As Object)

Le délégué du minuteur est spécifié lorsque le minuteur est construit et ne peut pas être modifié. La méthode ne s’exécute pas sur le thread qui a créé le minuteur ; il s’exécute sur un ThreadPool thread fourni par le système.

Lorsque vous créez un minuteur, vous pouvez spécifier un délai d’attente avant la première exécution de la méthode (délai d’échéance) et un délai d’attente entre les exécutions suivantes (période). La Timer classe a la même résolution que l’horloge système. Cela signifie que si la période est inférieure à la résolution de l’horloge système, le délégué TimerCallback s’exécute à intervalles définis par la résolution de l’horloge système, soit environ 15 millisecondes sur les systèmes Windows 7 et Windows 8. Vous pouvez modifier l’échéance et la période, ou désactiver le minuteur à l’aide de la Change méthode.

Lorsqu’un minuteur n’est plus nécessaire, utilisez la Dispose méthode pour libérer les ressources détenues par le minuteur. Notez que les rappels peuvent se produire après l’appel de la surcharge de méthode Dispose() , car le minuteur met en file d’attente les rappels pour l’exécution par les threads de pool de threads. Vous pouvez utiliser la surcharge de méthode Dispose(WaitHandle) pour attendre que tous les rappels soient terminés.

La méthode de rappel exécutée par le minuteur doit être réentrante, car elle est appelée sur ThreadPool les threads. Le rappel peut être exécuté simultanément sur deux threads de pool de threads si l’intervalle du minuteur est inférieur au temps nécessaire pour exécuter le rappel, ou si tous les threads de pool de threads sont en cours d’utilisation et que le rappel est mis en file d’attente plusieurs fois.

Cohérence de thread

Ce type est thread safe.

Voir aussi

• TimerCallback
• minuteurs
• Pool de threads managés