Partager via

Minuteries

.NET fournit trois minuteurs à utiliser dans un environnement multithread :

Remarque

Certaines implémentations .NET peuvent inclure des minuteurs supplémentaires :

  • System.Windows.Forms.Timer: composant Windows Forms qui déclenche un événement à intervalles réguliers. Le composant n’a pas d’interface utilisateur et est conçu pour une utilisation dans un environnement monothread.
  • System.Web.UI.Timer: composant ASP.NET qui effectue des postbacks de page web asynchrones ou synchrones à intervalles réguliers.
  • System.Windows.Threading.DispatcherTimer: minuteur intégré à la Dispatcher file d’attente qui est traité à un intervalle de temps spécifié et à une priorité spécifiée.

Classe « System.Threading.Timer »

La System.Threading.Timer classe vous permet d’appeler en permanence un délégué à intervalles de temps spécifiés. Vous pouvez également utiliser cette classe pour planifier un seul appel à un délégué dans un intervalle de temps spécifié. Le délégué est exécuté sur un fil d'exécution ThreadPool.

Lorsque vous créez un System.Threading.Timer objet, vous spécifiez un TimerCallback délégué qui définit la méthode de rappel, un objet d’état facultatif passé au rappel, la durée de délai avant le premier appel du rappel et l’intervalle de temps entre les appels de rappel. Pour annuler un minuteur en attente, appelez la Timer.Dispose méthode.

L’exemple suivant crée un minuteur qui appelle le délégué fourni pour la première fois après une seconde (1 000 millisecondes), puis l’appelle toutes les deux secondes. L’objet d’état dans l’exemple est utilisé pour compter le nombre de fois que le délégué est appelé. Le minuteur est arrêté lorsque le délégué a été appelé au moins 10 fois.

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

Pour plus d’informations et d’exemples, consultez System.Threading.Timer.

La classe System.Timers.Timer

Un autre minuteur qui peut être utilisé dans un environnement multithread est System.Timers.Timer, qui par défaut déclenche un événement sur un fil d'exécution ThreadPool.

Lorsque vous créez un System.Timers.Timer objet, vous pouvez spécifier l’intervalle de temps dans lequel déclencher un Elapsed événement. Utilisez la Enabled propriété pour indiquer si un minuteur doit déclencher un Elapsed événement. Si vous avez besoin qu’un Elapsed événement soit déclenché une seule fois après l’expiration de l’intervalle spécifié, définissez le AutoReset à false. La valeur par défaut de la AutoReset propriété est true, ce qui signifie qu’un Elapsed événement est déclenché régulièrement à l’intervalle défini par la Interval propriété.

Pour plus d’informations et d’exemples, consultez System.Timers.Timer.

La classe System.Threading.PeriodicTimer

La System.Threading.PeriodicTimer classe vous permet d’attendre des cycles individuels d’un intervalle spécifié, en effectuant un travail après l’appel PeriodicTimer.WaitForNextTickAsync.

Lorsque vous créez un System.Threading.PeriodicTimer objet, vous spécifiez un TimeSpan qui détermine la durée entre chaque graduation du minuteur. Au lieu de passer un rappel ou de définir un gestionnaire d’événements comme dans les classes de minuteur précédentes, vous réalisez des tâches directement dans le cadre, en attendant WaitForNextTickAsync pour faire avancer le minuteur par l’intervalle spécifié.

La WaitForNextTickAsync méthode retourne un ValueTask<bool>; true lors du déclenchement réussi du minuteur, et false lorsque le minuteur a été annulé en appelant PeriodicTimer.Dispose. WaitForNextTickAsync accepte éventuellement un CancellationToken, ce qui génère un TaskCanceledException lorsqu'une annulation a été demandée.

Pour plus d’informations, consultez System.Threading.PeriodicTimer.

Voir aussi