//******************************************************************************************************//  DynamicObjectPool`1.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 System.Collections.Concurrent;using System.Collections.Generic;using System.Linq;using System.Threading;using GSF.Diagnostics;using GSF.Threading; namespace GSF.Collections{    /// <summary>    /// Provides a thread safe queue that acts as a buffer pool.     /// </summary>    /// <typeparam name="T"></typeparam>    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable")]    public class DynamicObjectPool<T>        where T : class    {        private static readonly LogPublisher Log = Logger.CreatePublisher(typeof(DynamicObjectPool<T>), MessageClass.Component);         private readonly ScheduledTask m_collection;        private readonly ConcurrentQueue<T> m_queue;        private readonly Func<T> m_instanceObject;        private readonly Queue<int> m_countHistory;        private readonly int m_targetCount;         private int m_objectsCreated;         /// <summary>        /// Creates a new Resource Queue.        /// </summary>        /// <param name="instance">A delegate that will return the necessary queue.</param>        /// <param name="targetCount">the ideal number of objects that are always pending on the queue.</param>        public DynamicObjectPool(Func<T> instance, int targetCount)        {            if (instance == null)                throw new ArgumentNullException(nameof(instance));             m_targetCount = targetCount;            m_countHistory = new Queue<int>(100);            m_instanceObject = instance;            m_queue = new ConcurrentQueue<T>();            m_collection = new ScheduledTask();            m_collection.Running += CollectionRunning;            m_collection.Start(1000);        }         private void CollectionRunning(object sender, EventArgs<ScheduledTaskRunningReason> e)        {            m_collection.Start(1000);             m_countHistory.Enqueue(m_queue.Count);            if (m_countHistory.Count >= 60)            {                int objectsCreated = Interlocked.Exchange(ref m_objectsCreated, 0);                //if there were ever more than the target items in the queue over the past 60 seconds                //remove some items.                //However, don't remove items if the pool ever got to 0 and had objects that had to be created.                int min = m_countHistory.Min();                m_countHistory.Clear();                 if (objectsCreated > 250)                    Log.Publish(MessageLevel.Error, MessageFlags.PerformanceIssue | MessageFlags.UsageIssue, "Items Created since last collection cycle.", (objectsCreated).ToString());                else if (objectsCreated > 50)                    Log.Publish(MessageLevel.Warning, "Items Created since last collection cycle.", (objectsCreated).ToString());                else if (objectsCreated > 0)                    Log.Publish(MessageLevel.Info, "Items Created since last collection cycle.", (objectsCreated).ToString());                 if (min > m_targetCount && objectsCreated == 0)                {                    int itemsRemoved = (min - m_targetCount);                    if (itemsRemoved > 250)                        Log.Publish(MessageLevel.Error, MessageFlags.PerformanceIssue | MessageFlags.UsageIssue, "Removing items", itemsRemoved.ToString());                    else if (itemsRemoved > 50)                        Log.Publish(MessageLevel.Warning, "Removing items", itemsRemoved.ToString());                    else if (itemsRemoved > 0)                        Log.Publish(MessageLevel.Info, "Removing items", itemsRemoved.ToString());                }                 while (min > m_targetCount && objectsCreated == 0)                {                    T item;                    if (m_queue.TryDequeue(out item))                    {                        (item as IDisposable)?.Dispose();                    }                    else                    {                        return;                    }                    min--;                }            }        }         /// <summary>        /// Removes an item from the queue. If one does not exist, one is created.        /// </summary>        /// <returns></returns>        public T Dequeue()        {            T item;            if (m_queue.TryDequeue(out item))            {                return item;            }             Interlocked.Increment(ref m_objectsCreated);            return m_instanceObject();        }         /// <summary>        /// Adds an item back to the queue.        /// </summary>        /// <param name="resource">The resource to queue.</param>        public void Enqueue(T resource)        {            m_queue.Enqueue(resource);         }    }}