TimerCallback Délégué

Définition

Espace de noms:

System.Threading

Assemblys:

netstandard.dll, System.Runtime.dll

Représente la méthode qui gère des appels d'un Timer.

C#

public delegate void TimerCallback(object? state);

Paramètres

state

Object

Objet contenant des informations spécifiques à l'application et concernant la méthode appelée par ce délégué, ou null.

Exemples

L’exemple de code suivant montre comment créer le délégué utilisé avec la Timer classe .

C#

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.

Remarques

Utilisez un TimerCallback délégué pour spécifier la méthode appelée par un Timer. Cette méthode ne s’exécute pas dans le thread qui a créé le minuteur ; il s’exécute dans un thread de pool de threads distinct fourni par le système. Le TimerCallback délégué appelle la méthode une fois après l’expiration de l’heure de début, et continue à l’appeler une fois par intervalle de minuteur jusqu’à ce que la Dispose méthode soit appelée, ou jusqu’à ce que la Timer.Change méthode soit appelée avec la valeur Infinited’intervalle .

Notes

Les rappels peuvent se produire après l’appel de la Dispose() surcharge de méthode, car le minuteur met en file d’attente les rappels pour l’exécution par les threads du pool de threads. Vous pouvez utiliser la surcharge de Dispose(WaitHandle) méthode pour attendre que tous les rappels soient terminés.

Le délégué du minuteur est spécifié lorsque le minuteur est construit et ne peut pas être modifié. L’heure de début d’un Timer est passée dans le dueTime paramètre des Timer constructeurs, et le point est passé dans le period paramètre. Pour obtenir un exemple illustrant la création et l’utilisation d’un TimerCallback délégué, consultez System.Threading.Timer.

Méthodes d’extension

GetMethodInfo(Delegate)

Obtient un objet qui représente la méthode représentée par le délégué spécifié.

S’applique à

Voir aussi

• Timer
• ThreadPool
• Minuteurs