//******************************************************************************************************//  ReusableObjectPool.cs - Gbtc////  Copyright © 2010, 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 Eclipse Public License -v 1.0 (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/eclipse-1.0.php////  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/23/2011 - J. Ritchie Carroll//       Generated original version of source code.//  10/8/2012 - Danyelle Gilliam//        Modified Header////******************************************************************************************************    #region [ Contributor License Agreements ] //******************************************************************************************************////  Copyright © 2011, Grid Protection Alliance.  All Rights Reserved.////  The GPA licenses this file to you under the Eclipse Public License -v 1.0 (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/eclipse-1.0.php////  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.////****************************************************************************************************** #endregion using System;using System.Collections.Concurrent; namespace GSF{    /// <summary>    /// Represents a reusable object pool that can be used by an application.    /// </summary>    /// <remarks>    /// <para>    /// Object pooling can offer a significant performance boost in some scenarios. It is most effective when the cost    /// of construction is high and/or the rate of instantiation is high.    /// </para>    /// <para>    /// This object pool is statically created at application startup, one per type, and is available for all components    /// and classes within an application domain. Every time you need to use an object, you take one from the pool, use    /// it, then return it to the pool when done. This process can be much faster than creating a new object every time    /// you need to use one.    /// </para>    /// <para>    /// When objects implement <see cref="ISupportLifecycle"/>, the <see cref="ReusableObjectPool{T}"/> will automatically    /// attach to the <see cref="ISupportLifecycle.Disposed"/> event and return the object to the pool when it's disposed.    /// When an object is taken from the pool, the <see cref="ISupportLifecycle.Initialize"/> method will be called to     /// reinstantiate any need member variables. If class tracks a disposed flag, it should be reset during call to the    /// <see cref="ISupportLifecycle.Initialize"/> method so that class will be "un-disposed". Also, typical dispose    /// implementations call <see cref="GC.SuppressFinalize"/> in the <see cref="IDisposable.Dispose"/> method, as such the    /// <see cref="GC.ReRegisterForFinalize"/> should be called during <see cref="ISupportLifecycle.Initialize"/> method to    /// make sure class will be disposed by finalizer in case <see cref="IDisposable.Dispose"/> method is never called.    /// <example>    /// Here is an example class that implements <see cref="ISupportLifecycle"/> such that it will be automatically returned    /// to the pool when the class is disposed and automatically initialized when taken from the pool:    /// <code>    /// /// &lt;summary&gt;    /// /// Class that shows example implementation of reusable &lt;see cref="ISupportLifecycle"/&gt;.    /// /// &lt;/summary&gt;    /// public class ReusableClass : ISupportLifecycle    /// {    ///     #region [ Members ]    ///     ///     // Events    ///         ///     /// &lt;summary&gt;    ///     /// Occurs when the &lt;see cref="ReusableClass"/&gt; is disposed.    ///     /// &lt;/summary&gt;    ///     public event EventHandler Disposed;    ///         ///     // Fields    ///     private System.Timers.Timer m_timer;    // Example member variable that needs initialization and disposal    ///     private bool m_enabled;    ///     private bool m_disposed;    ///     ///     #endregion    ///    ///     #region [ Constructors ]    ///     ///     /// &lt;summary&gt;    ///     /// Releases the unmanaged resources before the &lt;see cref="ReusableClass"/&gt; object is reclaimed by &lt;see cref="GC"/&gt;.    ///     /// &lt;/summary&gt;    ///     ~ReusableClass()    ///     {    ///         Dispose(false);    ///     }    ///     ///     #endregion    ///     ///     #region [ Properties ]    ///     ///     /// &lt;summary&gt;    ///     /// Gets or sets a boolean value that indicates whether the &lt;see cref="ReusableClass"/&gt; object is currently enabled.    ///     /// &lt;/summary&gt;    ///     public bool Enabled    ///     {    ///         get    ///         {    ///             return m_enabled;    ///         }    ///         set    ///         {    ///             m_enabled = value;    ///     ///             if (m_timer != null)    ///                 m_timer.Enabled = m_enabled;    ///         }    ///     }    ///     ///     #endregion    ///     ///     #region [ Methods ]    ///     ///     /// &lt;summary&gt;    ///     /// Initializes the &lt;see cref="ReusableClass"/&gt; object.    ///     /// &lt;/summary&gt;    ///     public void Initialize()    ///     {    ///         // Undispose class instance if it is being reused    ///         if (m_disposed)    ///         {    ///             m_disposed = false;    ///             GC.ReRegisterForFinalize(this);    ///         }    ///             ///         m_enabled = true;    ///     ///         // Initialize member variables    ///         if (m_timer == null)    ///         {    ///             m_timer = new System.Timers.Timer(2000.0D);    ///             m_timer.Elapsed += m_timer_Elapsed;    ///             m_timer.Enabled = m_enabled;    ///         }    ///     }    ///     ///     /// &lt;summary&gt;    ///     /// Releases all the resources used by the &lt;see cref="ReusableClass"/&gt; object.    ///     /// &lt;/summary&gt;    ///     public void Dispose()    ///     {    ///         Dispose(true);    ///         GC.SuppressFinalize(this);    ///     }    ///     ///     /// &lt;summary&gt;    ///     /// Releases the unmanaged resources used by the &lt;see cref="ReusableClass"/&gt; object and optionally releases the managed resources.    ///     /// &lt;/summary&gt;    ///     /// &lt;param name="disposing"&gt;true to release both managed and unmanaged resources; false to release only unmanaged resources.&lt;/param&gt;    ///     protected virtual void Dispose(bool disposing)    ///     {    ///         if (!m_disposed)    ///         {    ///             try    ///             {    ///                 if (disposing)    ///                 {    ///                     // Dispose member variables    ///                     if (m_timer != null)    ///                     {    ///                         m_timer.Elapsed -= m_timer_Elapsed;    ///                         m_timer.Dispose();    ///                     }    ///                     m_timer = null;    ///                         ///                     m_enabled = false;    ///                 }    ///             }    ///             finally    ///             {    ///                 m_disposed = true;    ///     ///                 if (Disposed != null)    ///                     Disposed(this, EventArgs.Empty);    ///             }    ///         }    ///     }    ///     ///     // Handle timer event    ///     private void m_timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)    ///     {    ///         // Do work here...    ///     }    ///     ///     #endregion    /// }    /// </code>    /// </example>    /// </para>    /// <para>    /// If the pool objects do not implement <see cref="ISupportLifecycle"/> you can still use the object pool, but it    /// will be very imporant to return the object to the pool when you are finished using it. If you are using an object    /// scoped within a method, make sure to use a try/finally so that you can take the object within the try and return    /// the object within the finally. If you are using an object as a member scoped class field, make sure you use the    /// standard dispose pattern and return the object during the <see cref="IDisposable.Dispose"/> method call. In this    /// mode you will also need to manually initialze your object after you get it from the pool to reset its state.    /// </para>    /// </remarks>    /// <typeparam name="T">Type of object to pool.</typeparam>    public class ReusableObjectPool<T> where T : class, new()    {        private ConcurrentQueue<T> m_objectPool = new ConcurrentQueue<T>();         /// <summary>        /// Gets an object from the pool, or creates a new one if no pool items are available.        /// </summary>        /// <returns>An available object from the pool, or a new one if no pool items are available.</returns>        /// <remarks>        /// If type of <typeparamref name="T"/> implements <see cref="ISupportLifecycle"/>, the pool will attach        /// to the item's <see cref="ISupportLifecycle.Disposed"/> event such that the object can be automatically        /// restored to the pool upon <see cref="IDisposable.Dispose"/>. It will be up to class implementors to        /// make sure <see cref="ISupportLifecycle.Initialize"/> makes the class ready for use as this method will        /// always be called for an object being taken from the pool.        /// </remarks>        public T TakeObject()        {            T item;            bool newItem = false;             // Attempt to provide user with a queued item            if (!m_objectPool.TryDequeue(out item))            {                // No items are available, create a new item for the object pool                item = FastObjectFactory<T>.CreateObjectFunction();                newItem = true;            }             // Automatically handle class life cycle if item implements support for this            ISupportLifecycle lifecycleItem = item as ISupportLifecycle;             if (lifecycleItem != null)            {                // Attach to dispose event so item can be automatically returned to the pool                if (newItem)                    lifecycleItem.Disposed += LifecycleItem_Disposed;                 // Initialize or reinitialize (i.e., un-dispose) the item                lifecycleItem.Initialize();            }             return item;        }         /// <summary>        /// Returns object to the pool.        /// </summary>        /// <param name="item">Reference to the object being returned.</param>        /// <remarks>        /// If type of <typeparamref name="T"/> implements <see cref="ISupportLifecycle"/>, the pool will automatically        /// return the item to the pool when the <see cref="ISupportLifecycle.Disposed"/> event is raised, usually when        /// the object's <see cref="IDisposable.Dispose"/> method is called.        /// </remarks>        public void ReturnObject(T item)        {            if (item != null)                m_objectPool.Enqueue(item);        }         /// <summary>        /// Releases all the objects currently cached in the pool.        /// </summary>        public void Clear()        {            T item;             while (!m_objectPool.IsEmpty)            {                m_objectPool.TryDequeue(out item);            }        }         /// <summary>        /// Allocates the pool to the desired <paramref name="size"/>.        /// </summary>        /// <param name="size">Desired pool size.</param>        /// <exception cref="ArgumentOutOfRangeException">Pool <paramref name="size"/> must at least be one.</exception>        public void SetPoolSize(int size)        {            if (size < 1)                throw new ArgumentOutOfRangeException("size", "pool size must at least be one");             for (int i = 0; i < size - m_objectPool.Count; i++)            {                T item = FastObjectFactory<T>.CreateObjectFunction();                 // Automatically handle life cycle if item implements support for this                ISupportLifecycle lifecycleItem = item as ISupportLifecycle;                 // Attach to dispose event so item can be automatically returned to the pool                if (lifecycleItem != null)                    lifecycleItem.Disposed += LifecycleItem_Disposed;                 m_objectPool.Enqueue(item);            }        }         /// <summary>        /// Gets the number of items currently contained in the pool.        /// </summary>        /// <returns>The size of the pool.</returns>        public int GetPoolSize()        {            return m_objectPool.Count;        }         // Handler to automatically to return items to the queue         private void LifecycleItem_Disposed(object sender, EventArgs e)        {            ReturnObject(sender as T);        }         /// <summary>        /// Default static instance which can be shared throughout the application.        /// </summary>        public static readonly ReusableObjectPool<T> Default = new ReusableObjectPool<T>();     }     /// <summary>    /// Represents a reusable object pool that can be used by an application.    /// </summary>    /// <remarks>    /// <para>    /// See <see cref="ReusableObjectPool{T}"/> for more details on using object pooling.    /// </para>    /// <para>    /// <see cref="ReusableObjectPool"/> should be used when you only have the <see cref="Type"/> of an object available (such as when you are    /// using reflection), otherwise you should use the generic <see cref="ReusableObjectPool{T}"/>.    /// </para>    /// </remarks>    public class ReusableObjectPool    {        private static ConcurrentDictionary<Type, ConcurrentQueue<object>> s_objectPools = new ConcurrentDictionary<Type, ConcurrentQueue<object>>();         /// <summary>        /// Gets an object from the pool, or creates a new one if no pool items are available.        /// </summary>        /// <param name="type">Type of object to get from pool.</param>        /// <returns>An available object from the pool, or a new one if no pool items are available.</returns>        /// <exception cref="InvalidOperationException"><paramref name="type"/> does not support parameterless public constructor.</exception>        /// <remarks>        /// If <paramref name="type"/> implements <see cref="ISupportLifecycle"/>, the pool will attach        /// to the item's <see cref="ISupportLifecycle.Disposed"/> event such that the object can be automatically        /// restored to the pool upon <see cref="IDisposable.Dispose"/>. It will be up to class implementors to        /// make sure <see cref="ISupportLifecycle.Initialize"/> makes the class ready for use as this method will        /// always be called for an object being taken from the pool.        /// </remarks>        public static object TakeObject(Type type)        {            return TakeObject<object>(type);        }         /// <summary>        /// Gets an object from the pool, or creates a new one if no pool items are available.        /// </summary>        /// <param name="type">Type of object to get from pool.</param>        /// <typeparam name="T">Type of returned object to get from pool.</typeparam>        /// <returns>An available object from the pool, or a new one if no pool items are available.</returns>        /// <exception cref="InvalidOperationException">        /// <paramref name="type"/> does not support parameterless public constructor -or-         /// <paramref name="type"/> is not a subclass or interface implementation of function type definition.        /// </exception>        /// <remarks>        /// <para>        /// This function will validate that <typeparamref name="T"/> is related to <paramref name="type"/>.        /// </para>        /// <para>        /// If <paramref name="type"/> implements <see cref="ISupportLifecycle"/>, the pool will attach        /// to the item's <see cref="ISupportLifecycle.Disposed"/> event such that the object can be automatically        /// restored to the pool upon <see cref="IDisposable.Dispose"/>. It will be up to class implementors to        /// make sure <see cref="ISupportLifecycle.Initialize"/> makes the class ready for use as this method will        /// always be called for an object being taken from the pool.        /// </para>        /// </remarks>        public static T TakeObject<T>(Type type)        {            object item;            bool newItem = false;             // Get or create object pool associated with specified type            ConcurrentQueue<object> objectPool = s_objectPools.GetOrAdd(type, (objType) => new ConcurrentQueue<object>());             // Attempt to provide user with a queued item            if (!objectPool.TryDequeue(out item))            {                // No items are available, create a new item for the object pool                item = FastObjectFactory.GetCreateObjectFunction<T>(type)();                newItem = true;            }             // Automatically handle class life cycle if item implements support for this            ISupportLifecycle lifecycleItem = item as ISupportLifecycle;             if (lifecycleItem != null)            {                // Attach to dispose event so item can be automatically returned to the pool                if (newItem)                    lifecycleItem.Disposed += LifecycleItem_Disposed;                 // Initialize or reinitialize (i.e., un-dispose) the item                lifecycleItem.Initialize();            }             return (T)item;        }         /// <summary>        /// Returns object to the pool.        /// </summary>        /// <param name="item">Reference to the object being returned.</param>        /// <remarks>        /// If type of <paramref name="item"/> implements <see cref="ISupportLifecycle"/>, the pool will automatically        /// return the item to the pool when the <see cref="ISupportLifecycle.Disposed"/> event is raised, usually when        /// the object's <see cref="IDisposable.Dispose"/> method is called.        /// </remarks>        public static void ReturnObject(object item)        {            if (item != null)            {                ConcurrentQueue<object> objectPool;                 // Try to get object pool associated with the specified item's type                if (s_objectPools.TryGetValue(item.GetType(), out objectPool))                    objectPool.Enqueue(item);            }        }         /// <summary>        /// Releases all the objects currently cached in the specified pool.        /// </summary>        /// <param name="type">Type of pool to clear.</param>        public static void Clear(Type type)        {            ConcurrentQueue<object> objectPool;             // Try to get object pool associated with the specified type            if (s_objectPools.TryGetValue(type, out objectPool))            {                object item;                 while (!objectPool.IsEmpty)                {                    objectPool.TryDequeue(out item);                }            }        }         /// <summary>        /// Allocates the pool to the desired <paramref name="size"/>.        /// </summary>        /// <param name="type">Type of pool to initialize.</param>        /// <param name="size">Desired pool size.</param>        /// <exception cref="ArgumentOutOfRangeException">Pool <paramref name="size"/> must at least be one.</exception>        public static void SetPoolSize(Type type, int size)        {            if (size < 1)                throw new ArgumentOutOfRangeException("size", "pool size must at least be one");             // Get or create object pool associated with specified type            ConcurrentQueue<object> objectPool = s_objectPools.GetOrAdd(type, (objType) => new ConcurrentQueue<object>());             for (int i = 0; i < size - objectPool.Count; i++)            {                object item = FastObjectFactory.GetCreateObjectFunction(type)();                 // Automatically handle life cycle if item implements support for this                ISupportLifecycle lifecycleItem = item as ISupportLifecycle;                 // Attach to dispose event so item can be automatically returned to the pool                if (lifecycleItem != null)                    lifecycleItem.Disposed += LifecycleItem_Disposed;                 objectPool.Enqueue(item);            }        }         // Handler to automatically to return items to the queue         private static void LifecycleItem_Disposed(object sender, EventArgs e)

Lines 1–500 of 505. Load more