View difference between Paste ID: WymwySbr and E39dTeBT

 using System;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Threading;
 
-    public class MicroTimer : IDisposable
+public class MicroTimer : IDisposable
 {
-        [DllImport("winmm.dll")]
+	// Windows Multi-Media library to request a higher resolution period for the timer.
-        private static extern uint timeBeginPeriod(uint msec);
+	[DllImport("winmm.dll")]
 	private static extern uint timeBeginPeriod(uint msec);
-        private static readonly decimal TicksPerMillisecond = Stopwatch.Frequency / 1000M;
+
-        private decimal NextTime;
+	// Computes how many ticks are in each millisecond.
-        private Thread Iterator;
+	private static readonly decimal TicksPerMillisecond = Stopwatch.Frequency / 1000M;
-        private int Ms;
+	// Stores the next time the Timer should elapse at.
     private decimal NextTime;
-        public event ElapsedEventHandler Elapsed;
+	// The thread which to keep track of timing, as to not block.
-        public delegate void ElapsedEventHandler();
+    private Thread Iterator;
-        public decimal Interval { get; set; }
+	// Stores the number of millisecond the next iteration will wait for.
     private int Ms;
-        static MicroTimer()
+
 	// The Elapsed event, fired when the Timer has reached or exceeded its NextTIme value.
-            if (timeBeginPeriod(1) != 0) throw new Exception("High resolution timer not available.");
+    public event ElapsedEventHandler Elapsed;
     public delegate void ElapsedEventHandler();
 	// The number of ticks each iteration will take.
-        public MicroTimer() => Interval = TicksPerMillisecond;
+    public decimal Interval { get; set; }
 
-        public void Start(bool initial = false)
+	// Static constructor to request high resolution from Operation System. Throws if fails.
     static MicroTimer()
-            if (Iterator == null)
+
         if (timeBeginPeriod(1) != 0) throw new Exception("High resolution timer not available.");
-                NextTime = Stopwatch.GetTimestamp() + (initial ? 0 : Interval);
+    }
-                Iterator = new Thread(() =>
+
 	// Default constructor which initializes the interval to 1 second.
-                    while (true)
+    public MicroTimer() => Interval = TicksPerMillisecond;
-                    {
+
-                        if ((Ms = (int)(Math.Floor((NextTime - Stopwatch.GetTimestamp()) / TicksPerMillisecond))) > 0) Thread.Sleep(Ms);
+	// Starts the Timer if it hasn't started already.
-                        while (Stopwatch.GetTimestamp() < NextTime) ;
+    public void Start(bool initial = false)
-                        Elapsed?.Invoke();
+
-                        NextTime += Interval;
+        if (Iterator == null)
-                    }
+
-                })
+			// Sets the NextTime to the current time with the addition of the Interval (ticks per iteration) if specified.
             NextTime = Stopwatch.GetTimestamp() + (initial ? 0 : Interval);
-                    Priority = ThreadPriority.Highest,
+			// Initializes a new thread
-                    IsBackground = true
+            Iterator = new Thread(() =>
-                };
+
-                Iterator.Start();
+				// Infinite loop to track time.
-            }
+				while (true)
                 {
 					// Assigns Ms to how much time in millisecond until NextTime is reached and if that evaluation is greater than 0. If it is, sleep for that amount in milliseconds.
-        public void Stop()
+                    if ((Ms = (int)(Math.Floor((NextTime - Stopwatch.GetTimestamp()) / TicksPerMillisecond))) > 0) Thread.Sleep(Ms);
 					// Poll with the remaining left over Ticks (sub millisecond precision).
-            if (Iterator != null)
+                    while (Stopwatch.GetTimestamp() < NextTime) ;
 					// Fire Elapsed Event if not null.
-                Iterator.Abort();
+                    Elapsed?.Invoke();
-                Iterator = null;
+					// Set the NextTime to the next iteration.
-            }
+					NextTime += Interval;
 				}
 			})
-        public void Dispose() => Iterator?.Abort();
+			{
-    }
+				Priority = ThreadPriority.Highest, // Have this thread at a high priority.
 				IsBackground = true // Prevent thread from still running after application has closed.
 			};
 			Iterator.Start(); // Starts the Thread.
 		}
 	}
 
 	// Stops the Thread and nulls it.
     public void Stop()
     {
 		if (Iterator != null)
         {
             Iterator.Abort();
             Iterator = null;
         }
     }
 
 	// Disposes this object (implemented to the using statement can be used).
 	public void Dispose() => Iterator?.Abort();
 }