initial checkin of yaulw (locally)

Thread/SingleThreadTimer.cs

@@ -0,0 +1,143 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Timers;
+
+namespace Yaulw.Thread
+{
+    /// <summary>
+    /// Single Threaded Timer * only calls the elapsed event handler once and only
+    /// will call it again, if the elapsed event handler returns
+    /// </summary>
+    public class SingleThreadTimer
+    {
+        #region Private Members
+
+        private STElapsedEventHandler _elapsedHandler = null;
+        private uint _IntervalMilliseconds = 0;
+        private System.Threading.Thread _thread = null;
+
+        #endregion
+
+        #region Construction
+
+        /// <summary>
+        /// Creates a new Single-threaded System.Timer
+        /// </summary>
+        /// <param name="ElapsedHandler">Event Handler for Timer</param>
+        /// <param name="IntervalMiliseconds">Interval in Miliseconds</param>
+        /// <param name="StartEnabled">True to start the timer upon creation, false otherwise</param>
+        /// <returns>A Timer Object, which should be Disposed by Caller</returns>
+        public SingleThreadTimer(STElapsedEventHandler ElapsedHandler, uint IntervalMilliseconds, bool StartEnabled)
+        {
+            _elapsedHandler = ElapsedHandler;
+            _IntervalMilliseconds = IntervalMilliseconds;
+            if (_elapsedHandler == null || _IntervalMilliseconds == 0)
+                throw new ArgumentException("Invalid ElapsedHandler or Milliseconds. ElapsedHandler can not be null. Milliseconds can not be 0.");
+
+            if (StartEnabled)
+                Start();
+        }
+
+        #endregion
+
+        #region Private Helpers
+
+        /// <summary>
+        /// Main DoWork() Function, calls the ElapsedHandler at every interval
+        /// * Single threaded * ElapsedHandler will only get called again, once it returns
+        /// </summary>
+        private void STimerThreadMethod()
+        {
+            do
+            {
+                if (_IntervalMilliseconds > 0)
+                    System.Threading.Thread.Sleep((int)_IntervalMilliseconds);
+
+                if (_elapsedHandler != null)
+                    _elapsedHandler(this, new STElapsedEventArgs(DateTime.Now));
+            }
+            while (true);
+        }
+
+        #endregion
+
+        #region Public Delegates
+
+        /// <summary>
+        /// ElapsedEvent Handler is called when the time interval elapsed
+        /// </summary>
+        /// <param name="sender">Sends the STimer Object</param>
+        /// <param name="e">sends the Timestampe when the interval elapsed</param>
+        public delegate void STElapsedEventHandler(object sender, STElapsedEventArgs e);
+
+        /// <summary>
+        /// ElapsedEventArgs are called with the time stamp when the Event was raised
+        /// </summary>
+        public class STElapsedEventArgs : EventArgs
+        {
+            public DateTime SignalTime { get; private set; }
+            public STElapsedEventArgs(DateTime SignalTime) { this.SignalTime = SignalTime; }
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Manually Start the STimer
+        /// </summary>
+        public bool Start()
+        {            
+            Stop(); // First Stop(), an existing Timer
+            return Start(_IntervalMilliseconds);
+        }
+
+        /// <summary>
+        /// Manually Start the STimer at a new Interval
+        /// </summary>
+        /// <param name="tsInterval">Interval as a TimeSpan</param>
+        public bool Start(TimeSpan tsInterval)
+        {
+            Stop(); // First Stop(), an existing Timer
+            return Start((uint)tsInterval.TotalMilliseconds);
+        }
+
+        /// <summary>
+        /// Manually Start the STimer at a new Interval
+        /// </summary>
+        /// <param name="IntervalMiliseconds">Interval in Miliseconds</param>
+        public bool Start(uint IntervalMiliseconds)
+        {
+            try
+            {
+                Stop(); // First Stop(), an existing Timer
+                if (IntervalMiliseconds > 0)
+                    _IntervalMilliseconds = IntervalMiliseconds;
+                if (_thread == null)
+                    _thread = TStarter.StartThread(STimerThreadMethod, ("STimer-" + _elapsedHandler.Method.Name), System.Threading.ApartmentState.MTA, false, System.Threading.ThreadPriority.Normal);
+                return ((_thread != null) && (_thread.IsAlive));
+            }
+            catch (Exception) { /* ignore */ }
+            return false;
+        }
+
+        /// <summary>
+        /// Manually Stop the STimer
+        /// </summary>
+        public void Stop()
+        {
+            try
+            {
+                if (_thread != null)
+                    _thread.Abort();                    
+            }
+            catch (Exception) { /* ignore */ }
+            _thread = null;
+        }
+
+        #endregion
+
+    }
+}