//******************************************************************************************************//  EventTimer.cs - Gbtc////  Copyright © 2016, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may//  not use this file except in compliance with the License. You may obtain a copy of the License at:////      http://www.opensource.org/licenses/MIT////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  11/17/2016 - Steven E. Chisholm//       Generated original version of source code. //       ////****************************************************************************************************** using System;using GSF.Diagnostics; namespace GSF.Threading{    /// <summary>    /// A reoccurring timer that fires on a given interval. This event timer will always fire at the top of the specified interval.    /// If the callback takes too long, the next interval will be skipped.    /// </summary>    public class EventTimer        : DisposableLoggingClassBase    {        /// <summary>        /// An event that fires every time the specified period elapses.        /// </summary>        public event EventHandler Elapsed;         ScheduledTask m_timer;        TimeSpan m_period;        TimeSpan m_dayOffset;        bool m_started;        bool m_disposed;         /// <summary>        /// Creates a <see cref="EventTimer"/>        /// </summary>        /// <param name="period"></param>        /// <param name="dayOffset"></param>        EventTimer(TimeSpan period, TimeSpan dayOffset)            : base(MessageClass.Component)        {            m_period = period;            m_dayOffset = dayOffset;            Log.InitialStackMessages = Log.InitialStackMessages.Union("Timer", string.Format("EventTimer: {0} in {1}", m_period.ToString(), m_dayOffset.ToString()));        }         /// <summary>        /// The amount of time before the next interval will occur.        /// </summary>        public TimeSpan TimeUntilNextExecution        {            get            {                long current = DateTime.UtcNow.Ticks;                long subtractOffset = current - m_dayOffset.Ticks;                long remainderTicks = m_period.Ticks - subtractOffset % m_period.Ticks;                int delay = (int)(remainderTicks / TimeSpan.TicksPerMillisecond) + 1;                if (delay < 10)                    delay += (int)m_period.TotalMilliseconds;                return new TimeSpan(delay * TimeSpan.TicksPerMillisecond);            }        }         /// <summary>        /// Modifies the timer. Note, it takes some time for this timer to go into effect.        /// </summary>        /// <param name="period"></param>        /// <param name="dayOffset"></param>        public void ChangeTimer(TimeSpan period, TimeSpan dayOffset = default(TimeSpan))        {            m_period = period;            m_dayOffset = dayOffset;        }         /// <summary>        /// This timer will reliably fire the directory polling every interval.        /// </summary>        /// <param name="sender"></param>        /// <param name="e"></param>        void TimerRunning(object sender, EventArgs<ScheduledTaskRunningReason> e)        {            //This cannot be combined with m_directoryPolling because             //Scheduled task does not support managing multiple conflicting timers.            if (e.Argument == ScheduledTaskRunningReason.Disposing)                return;             try            {                Elapsed?.Invoke(this, EventArgs.Empty);            }            catch (Exception ex)            {                Log.Publish(MessageLevel.Error, "Event Timer Exception on raising event.", null, null, ex);            }             RestartTimer();        }         /// <summary>        /// Immediately executes the timer, not waiting for the elapsed interval.        /// </summary>        public void RunNow()        {            m_timer.Start();        }         void RestartTimer()        {            long current = DateTime.UtcNow.Ticks;            long subtractOffset = current - m_dayOffset.Ticks;            long remainderTicks = m_period.Ticks - subtractOffset % m_period.Ticks;            int delay = (int)(remainderTicks / TimeSpan.TicksPerMillisecond) + 1;            if (delay < 10)                delay += (int)m_period.TotalMilliseconds;             m_timer.Start(delay);        }         /// <summary>        /// Starts the watching        /// </summary>        public void Start(ThreadingMode mode = ThreadingMode.ThreadPool)        {            if (m_started)                return;            m_started = true;             Log.Publish(MessageLevel.Debug, "EventTimer Started");             m_timer = new ScheduledTask(mode);            m_timer.Running += TimerRunning;            RestartTimer();        }         /// <summary>        /// Releases the unmanaged resources used by the <see cref="DisposableLoggingClassBase"/> object and optionally releases the managed resources.        /// </summary>        /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2213:DisposableFieldsShouldBeDisposed", MessageId = "m_timer")]        protected override void Dispose(bool disposing)        {            if (!m_disposed)            {                m_disposed = true;                m_timer?.Dispose();                m_timer = null;            }            base.Dispose(disposing);        }         /// <summary>        /// Creates a <see cref="EventTimer"/> on the specified interval.        /// </summary>        /// <param name="period">How often the time will reset</param>        /// <param name="dayOffset">The offset as represented in UTC time when the event should fire</param>        /// <returns></returns>        public static EventTimer Create(TimeSpan period, TimeSpan dayOffset = default(TimeSpan))        {            return new EventTimer(period, dayOffset);        }         /// <summary>        /// Creates a <see cref="EventTimer"/> on the specified interval.        /// </summary>        /// <param name="periodInSecond">How often the time will reset</param>        /// <param name="dayOffsetInSecond">The offset as represented in UTC time when the event should fire</param>        /// <returns></returns>        public static EventTimer CreateSeconds(double periodInSecond, double dayOffsetInSecond = 0)        {            return new EventTimer(new TimeSpan((long)(periodInSecond * TimeSpan.TicksPerSecond)), new TimeSpan((long)(dayOffsetInSecond * TimeSpan.TicksPerSecond)));        }         /// <summary>        /// Creates a <see cref="EventTimer"/> on the specified interval.        /// </summary>        /// <param name="periodInMinutes">How often the time will reset</param>        /// <param name="dayOffsetInMinutes">The offset as represented in UTC time when the event should fire</param>        /// <returns></returns>        public static EventTimer CreateMinutes(double periodInMinutes, double dayOffsetInMinutes = 0)        {            return new EventTimer(new TimeSpan((long)(periodInMinutes * TimeSpan.TicksPerMinute)), new TimeSpan((long)(dayOffsetInMinutes * TimeSpan.TicksPerMinute)));        }         /// <summary>        /// Creates a <see cref="EventTimer"/> on the specified interval.        /// </summary>        /// <param name="periodInHours">How often the time will reset</param>        /// <param name="dayOffsetInHours">The offset as represented in UTC time when the event should fire</param>        /// <returns></returns>        public static EventTimer CreateHours(double periodInHours, double dayOffsetInHours = 0)        {            return new EventTimer(new TimeSpan((long)(periodInHours * TimeSpan.TicksPerHour)), new TimeSpan((long)(dayOffsetInHours * TimeSpan.TicksPerHour)));        }      }}