Click here to Skip to main content
13,448,598 members (53,692 online)
Click here to Skip to main content
Articles » Languages » C# » Utilities » Revisions
Add your own
alternative version


197 bookmarked
Posted 31 Jul 2010

Microsecond and Millisecond C# Timer

, 20 Feb 2013
Rate this:
Please Sign up or sign in to vote.
MicroTimer: A microsecond and millisecond timer in C# that is used in a similar way to the .NET System.Timers.Timer.
This is an old version of the currently published article.


Anyone who has used the .NET System.Timers.Timer class for low interval times will realise that it does not offer a very high resolution. The resolution will be system dependant, but a maximum resolution is usually around 15ms (System.Windows.Forms.Timer has an even worse resolution, although it is unlikely a UI will need to be updated this fast). Significantly better performance can be achieved using the Win32 multimedia timer (there are various .NET projects that wrap this timer); however, there are no timers available in the microsecond range.

The problem I encountered was that I needed to send an Ethernet UDP message packet out every 800µs (0.8ms); it did not matter if a packet was slightly delayed or did not go off exactly 800µs after the last one. Basically, what I needed was a microsecond timer that was accurate the majority of the time.

The fundamental problem with a software timer in the region of 1ms is that Windows is a non real-time Operating System (RTOS), and is not suitable for generating regular and accurate events around the 1ms mark. MicroTimer cannot and does not solve this problem; however, it does offer a microsecond timer which offers a reasonable degree of accuracy (approx. 1µs) the majority (approx. 99.9%) of the time. The trouble is, the 0.1% of the time, the timer can be very inaccurate (whilst the Operating System gives some of the processing time to other threads and processes). The accuracy is highly system/processor dependant; a faster system will result in a more accurate timer.

The beauty of MicroTimer is that it is called in a very similar way to the existing System.Timers.Timer class; however, the interval is set in microseconds (as opposed to milliseconds in System.Timers.Timer). On each timed event, MicroTimer invokes the predefined (OnTimedEvent) callback function. The MicroTimerEventArgs properties provide information (to the microsecond) on when exactly (and how late) the timer was invoked.

Using the code

'MicroLibrary.cs' encompasses three classes (under the namespace 'MicroLibrary'):

  • MicroStopwatch - This derives from and extends the System.Diagnostics.Stopwatch class; importantly, it provides the additional property 'ElapsedMicroseconds'. This is useful as a standalone class where the elapsed microseconds from when the stopwatch was started can be directly obtained.
  • MicroTimer - Designed so it operates in a very similar way to the System.Timers.Timer class, it has a timer interval in microseconds, and a Start and Stop method (or Enabled property). It implements a custom event handler (MicroTimerElapsedEventHandler) that fires every interval. The 'NotificationTimer' function is where the 'work' is done, and is run in a separate high priority thread. It should be noted that MicroTimer is inefficient and very processor hungry as the 'NotificationTimer' function runs a tight while loop until the elapsed microseconds is greater than the next interval. This is not ideal; however, for such small intervals, this is probably the only practical solution.
  • MicroTimerEventArgs - Derived from System.EventArgs, this class provides an object for holding information about the event. Namely, the number of times the event has fired, the absolute time (in microseconds) from when the timer was started, how late the event was, and also the execution time of the callback function (for the previous event). From this data, a range of timer information can be derived.

By design, the amount of work done in the callback function (OnTimedEvent) must be small (e.g., update a variable or fire off a UDP packet). To that end, the work done in the callback function must take significantly less time than the timer interval. Separate threads could be spawned for longer tasks; however, this goes outside the scope of this article. As discussed earlier, because Windows is not a real time Operating System, the callback function (OnTimedEvent) may be late; if this happens and any particular interval is delayed, there are two options:

  • Either: Set the property 'IgnoreEventIfLateBy' whereby the callback function (OnTimedEvent) will not be called if the timer is late by the specified number of microseconds. The advantage of this is the timer will not attempt to 'catch up', i.e., it will not call the callback function in quick succession in an attempt to catch up. The disadvantage is that some events will be missed.
  • Or: By default, MicroTimer will always try and catch up on the next interval. The advantage of this is the number of times the OnTimeEvent is called will always be correct for the total elapsed time (which is why the OnTimedEvent must take significantly less time than the interval; if it takes a similar or longer time, MicroTimer can never 'catch up' and the timer event will always be late). The disadvantage of this is when it's trying to 'catch up', the actual interval achieved will be much less than the required interval as the callback function is called in quick succession in an attempt to catch up.

The code below shows the 'MicroLibrary' namespace (MicroLibrary.cs) which contains the three classes, MicroStopwatch, MicroTimer, and MicroTimerEventArgs. See the 'Download source' link above.

using System;

namespace MicroLibrary
    /// <summary>
    /// MicroStopwatch class
    /// </summary>
    public class MicroStopwatch : System.Diagnostics.Stopwatch
        readonly double _microSecPerTick
            = 1000000D / System.Diagnostics.Stopwatch.Frequency;

        public MicroStopwatch()
            if (!System.Diagnostics.Stopwatch.IsHighResolution)
                throw new Exception("On this system the high-resolution " +
                                    "performance counter is not available");

        public long ElapsedMicroseconds
                return (long)(ElapsedTicks * _microSecPerTick);

    /// <summary>
    /// MicroTimer class
    /// </summary>
    public class MicroTimer
        public delegate void MicroTimerElapsedEventHandler(
                             object sender,
                             MicroTimerEventArgs timerEventArgs);
        public event MicroTimerElapsedEventHandler MicroTimerElapsed;

        System.Threading.Thread _threadTimer = null;
        long _ignoreEventIfLateBy = long.MaxValue;
        long _timerIntervalInMicroSec = 0;
        bool _stopTimer = true;

        public MicroTimer()

        public MicroTimer(long timerIntervalInMicroseconds)
            Interval = timerIntervalInMicroseconds;

        public long Interval
                return System.Threading.Interlocked.Read(
                    ref _timerIntervalInMicroSec);
                    ref _timerIntervalInMicroSec, value);

        public long IgnoreEventIfLateBy
                return System.Threading.Interlocked.Read(
                    ref _ignoreEventIfLateBy);
                    ref _ignoreEventIfLateBy, value <= 0 ? long.MaxValue : value);

        public bool Enabled
                if (value)
                return (_threadTimer != null && _threadTimer.IsAlive);

        public void Start()
            if (Enabled || Interval <= 0)

            _stopTimer = false;

            System.Threading.ThreadStart threadStart = delegate()
                NotificationTimer(ref _timerIntervalInMicroSec,
                                  ref _ignoreEventIfLateBy,
                                  ref _stopTimer);

            _threadTimer = new System.Threading.Thread(threadStart);
            _threadTimer.Priority = System.Threading.ThreadPriority.Highest;

        public void Stop()
            _stopTimer = true;

            if (_threadTimer != null && _threadTimer.ManagedThreadId ==

            while (Enabled)

        void NotificationTimer(ref long timerIntervalInMicroSec,
                               ref long ignoreEventIfLateBy,
                               ref bool stopTimer)
            int  timerCount = 0;
            long nextNotification = 0;

            MicroStopwatch microStopwatch = new MicroStopwatch();

            while (!stopTimer)
                long callbackFunctionExecutionTime =
                    microStopwatch.ElapsedMicroseconds - nextNotification;

                long timerIntervalInMicroSecCurrent =
                    System.Threading.Interlocked.Read(ref timerIntervalInMicroSec);
                long ignoreEventIfLateByCurrent =
                    System.Threading.Interlocked.Read(ref ignoreEventIfLateBy);

                nextNotification += timerIntervalInMicroSecCurrent;
                long elapsedMicroseconds = 0;

                while ( (elapsedMicroseconds = microStopwatch.ElapsedMicroseconds)
                        < nextNotification)

                long timerLateBy = elapsedMicroseconds - nextNotification;

                if (timerLateBy >= ignoreEventIfLateByCurrent)

                MicroTimerEventArgs microTimerEventArgs =
                     new MicroTimerEventArgs(timerCount,
                MicroTimerElapsed(this, microTimerEventArgs);


    /// <summary>
    /// MicroTimer Event Argument class
    /// </summary>
    public class MicroTimerEventArgs : EventArgs
        // Simple counter, number times timed event (callback function) executed
        public int  TimerCount { get; private set; }

        // Time when timed event was called since timer started
        public long ElapsedMicroseconds { get; private set; }

        // How late the timer was compared to when it should have been called
        public long TimerLateBy { get; private set; }

        // Time it took to execute previous call to callback function (OnTimedEvent)
        public long CallbackFunctionExecutionTime { get; private set; }

        public MicroTimerEventArgs(int  timerCount,
                                   long elapsedMicroseconds,
                                   long timerLateBy,
                                   long callbackFunctionExecutionTime)
            TimerCount = timerCount;
            ElapsedMicroseconds = elapsedMicroseconds;
            TimerLateBy = timerLateBy;
            CallbackFunctionExecutionTime = callbackFunctionExecutionTime;

The code below shows a very simple (console application) implementation of the MicroTimer class with the interval set to 1,000µs (1ms). See the 'Download demo project' link above.

using System;

namespace MicroTimerConsoleDemo
    class Program
        static void Main(string[] args)
            Program program = new Program();

        private void MicroTimerTest()
            // Instantiate new MicroTimer and add event handler
            MicroLibrary.MicroTimer microTimer = new MicroLibrary.MicroTimer();
            microTimer.MicroTimerElapsed +=
                new MicroLibrary.MicroTimer.MicroTimerElapsedEventHandler(OnTimedEvent);

            microTimer.Interval = 1000; // Call micro timer every 1000µs (1ms)

            // Can choose to ignore event if late by Xµs (by default will try to catch up)
            // microTimer.IgnoreEventIfLateBy = 500; // 500µs (0.5ms)

            microTimer.Enabled = true; // Start timer

            // Do something whilst events happening, for demo sleep 2000ms (2sec)

            microTimer.Enabled = false; // Stop timer

            // Wait for user input

        private void OnTimedEvent(object sender,
                                  MicroLibrary.MicroTimerEventArgs timerEventArgs)
            // Do something small that takes significantly less time than Interval
                "Count = {0:#,0}  Timer = {1:#,0} µs, " + 
                "LateBy = {2:#,0} µs, ExecutionTime = {3:#,0} µs",
                timerEventArgs.TimerCount, timerEventArgs.ElapsedMicroseconds,
                timerEventArgs.TimerLateBy, timerEventArgs.CallbackFunctionExecutionTime));

The screenshot below shows the console output. The performance varies on different runs, but was usually accurate to 1µs. Due to system caching, the accuracy was worse on the first run and got better after the first few events. This test was on a 2GHz Dell Inspiron 1545 with an Intel Core 2 Duo (running Windows 7 64bit). The performance improved significantly on faster machines.



MicroTimer is designed for situations were a very quick timer is required (around the 1ms mark); however, due to the non real-time nature of the Windows Operating System, it can never be accurate. However, as no other microsecond software timers are available, it does offer a reasonable solution for this task (and although processor hungry, is reasonably accurate on fast systems).


  • 31 July 2010 - Article submitted.


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

United Kingdom United Kingdom
No Biography provided

You may also be interested in...

Comments and Discussions

Discussions on this specific version of this article. Add your comments on how to improve this article here. These comments will not be visible on the final published version of this article.
GeneralMy vote of 5 Pin
Member 134234838-Mar-18 5:43
memberMember 134234838-Mar-18 5:43 
QuestionDetect IgnoreEventIfLateBy Pin
Member 1293869812-Oct-17 3:46
memberMember 1293869812-Oct-17 3:46 
AnswerRe: Detect IgnoreEventIfLateBy Pin
ken.loveday16-Nov-17 23:35
memberken.loveday16-Nov-17 23:35 
QuestionReduce CPU load by using Thread.Sleep rather than Thread.SpinWait Pin
Member 1293869812-Jun-17 22:33
memberMember 1293869812-Jun-17 22:33 
AnswerRe: Reduce CPU load by using Thread.Sleep rather than Thread.SpinWait Pin
ken.loveday26-Jul-17 2:17
memberken.loveday26-Jul-17 2:17 
QuestionI wrapped MicroLibrary in a DLL so it can be used from AutoHotkey Pin
Clive Galway1-Apr-17 6:55
memberClive Galway1-Apr-17 6:55 
AnswerRe: I wrapped MicroLibrary in a DLL so it can be used from AutoHotkey Pin
ken.loveday2-Apr-17 23:47
memberken.loveday2-Apr-17 23:47 
Praisethanks Pin
Member 107731455-Mar-17 15:58
memberMember 107731455-Mar-17 15:58 
SuggestionTo reduce CPU usage... Pin
patel.prem17-Aug-16 0:05
memberpatel.prem17-Aug-16 0:05 
GeneralRe: To reduce CPU usage... Pin
ken.loveday19-Aug-16 1:48
memberken.loveday19-Aug-16 1:48 
GeneralRe: To reduce CPU usage... Pin
patel.prem21-Aug-16 18:48
memberpatel.prem21-Aug-16 18:48 
GeneralRe: To reduce CPU usage... Pin
Clive Galway1-Apr-17 7:09
memberClive Galway1-Apr-17 7:09 
GeneralMy vote of 5 Pin
ghammock17-Apr-16 15:46
memberghammock17-Apr-16 15:46 
GeneralRe: My vote of 5 Pin
ken.loveday17-Apr-16 21:43
memberken.loveday17-Apr-16 21:43 
QuestionGradually gets slower Pin
PJonHar8-Dec-15 3:41
memberPJonHar8-Dec-15 3:41 
AnswerRe: Gradually gets slower Pin
ken.loveday8-Dec-15 10:52
memberken.loveday8-Dec-15 10:52 
GeneralRe: Gradually gets slower Pin
PJonHar8-Dec-15 11:30
memberPJonHar8-Dec-15 11:30 
QuestionHow to reset the timer? Pin
Member 119203497-Dec-15 15:46
memberMember 119203497-Dec-15 15:46 
AnswerRe: How to reset the timer? Pin
ken.loveday8-Dec-15 10:48
memberken.loveday8-Dec-15 10:48 
Questiontimer using the maximum heart processor resources Pin
luckyluche27-Aug-15 21:44
memberluckyluche27-Aug-15 21:44 
AnswerRe: timer using the maximum heart processor resources Pin
ken.loveday28-Aug-15 0:02
memberken.loveday28-Aug-15 0:02 
GeneralRe: timer using the maximum heart processor resources Pin
luckyluche28-Aug-15 1:26
memberluckyluche28-Aug-15 1:26 
GeneralUnable to unzip source folders Pin
Anil Vittal12-May-15 20:31
professionalAnil Vittal12-May-15 20:31 
GeneralRe: Unable to unzip source folders Pin
ken.loveday13-May-15 0:20
memberken.loveday13-May-15 0:20 
GeneralMy vote of 5 Pin
Alessio Regalbuto8-Apr-15 0:33
professionalAlessio Regalbuto8-Apr-15 0:33 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Permalink | Advertise | Privacy | Terms of Use | Mobile
Web04-2016 | 2.8.180318.3 | Last Updated 20 Feb 2013
Article Copyright 2010 by ken.loveday
Everything else Copyright © CodeProject, 1999-2018
Layout: fixed | fluid