//******************************************************************************************************//  StaticTimer.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://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/10/2016 - Stephen C. Wills//       Generated original version of source code.////****************************************************************************************************** using System;using System.Collections.Concurrent;using System.Collections.Generic; namespace GSF.Threading{    /// <summary>    /// Represents a timer manager which registers callbacks    /// with existing timers to reduce thread pool queue burden.    /// </summary>    public class StaticTimer    {        #region [ Members ]         // Nested Types        private class TimerAction        {            private WeakAction m_action;            private CancellationToken m_cancellationToken;             public TimerAction(Action action, CancellationToken cancellationToken)            {                m_action = new WeakAction(action);                m_cancellationToken = cancellationToken;            }             public bool IsCancelled            {                get                {                    return m_cancellationToken.IsCancelled;                }            }             public bool TryInvoke()            {                return m_action.TryInvoke();            }        }         // Fields        private readonly ConcurrentDictionary<int, ConcurrentQueue<TimerAction>> m_dataStreamMonitorActions;         #endregion         #region [ Constructors ]         /// <summary>        /// Creates a new instance of the <see cref="StaticTimer"/> class.        /// </summary>        public StaticTimer()        {            m_dataStreamMonitorActions = new ConcurrentDictionary<int, ConcurrentQueue<TimerAction>>();        }         #endregion         #region [ Methods ]         /// <summary>        /// Registers the given callback with the timer running at the given interval.        /// </summary>        /// <param name="interval">The interval at which to run the timer.</param>        /// <param name="monitorAction">The action to be performed when the timer is triggered.</param>        public ICancellationToken RegisterDataStreamMonitor(int interval, Action monitorAction)        {            CancellationToken cancellationToken = new CancellationToken();            RegisterDataStreamMonitor(interval, new TimerAction(monitorAction, cancellationToken));            return cancellationToken;        }         private void RegisterDataStreamMonitor(int interval, TimerAction monitorAction)        {            ConcurrentQueue<TimerAction> newQueue = null;            ConcurrentQueue<TimerAction> queue;             lock (m_dataStreamMonitorActions)            {                queue = m_dataStreamMonitorActions.GetOrAdd(interval, i => newQueue = new ConcurrentQueue<TimerAction>());                queue.Enqueue(monitorAction);            }             if (queue == newQueue)                StartTimer(interval, queue);        }         private void StartTimer(int interval, ConcurrentQueue<TimerAction> queue)        {            MonitorDataStream(interval, queue, new List<TimerAction>());        }         private void MonitorDataStream(int interval, ConcurrentQueue<TimerAction> queue, List<TimerAction> list)        {            TimerAction action;             for (int i = 0; i < list.Count; i++)            {                action = list[i];                 // False here indicates that the                // action has been garbage collected                if (action.IsCancelled || !action.TryInvoke())                {                    int end = list.Count - 1;                    list[i] = list[end];                    list.RemoveAt(end);                    i--;                }            }             // The queue is only used to populate the            // list from outside the async loop            while (queue.TryDequeue(out action))                list.Add(action);             if (list.Count > 0)            {                // We still have callbacks in the list so continue the async loop                new Action(() => MonitorDataStream(interval, queue, list)).DelayAndExecute(interval);            }            else            {                lock (m_dataStreamMonitorActions)                {                    // We are retiring this async loop so we need                    // to remove its queue from the lookup table                    m_dataStreamMonitorActions.TryRemove(interval, out queue);                     // However, actions may have been queued up in the meantime                    // so we need to re-register them with a new async loop                    while (queue.TryDequeue(out action))                        RegisterDataStreamMonitor(interval, action);                }            }        }         #endregion         #region [ Static ]         // Static Fields         /// <summary>        /// Default instance of the <see cref="StaticTimer"/> class.        /// </summary>        public static readonly StaticTimer Default = new StaticTimer();         #endregion    }}