.Net中实现简单对象池

       我们首先定义一个对象的基类ObjectPoolBase，用于计数。像这样：

 1     /// <summary>
 2     /// ObjectPoolBase
 3     /// </summary>
 4     /// <remarks>Author Petter Liu http://wintersun.cnblogs.com </remarks>
 5     public class ObjectPoolBase
 6     {
 7         /// <summary>
 8         /// ObjectPoolBase Counter
 9         /// </summary>
         public static int Counter = 0;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ObjectPoolBase"/> class.
         /// </summary>
         public ObjectPoolBase()
         {
             ++Counter;
         }
     }

接下来再来写一个池，使用了Queue<T>，像这样

 1  /// <summary>
 2     /// ObjectPool Generic Verison
 3     /// <seealso cref="http://www.c-sharpcorner.com/UploadFile/vmsanthosh.chn/109042007094154AM/1.aspx"/>
 4     /// <remarks>Author Petter Liu http://wintersun.cnblogs.com </remarks>
 5     /// </summary>
 6     /// <typeparam name="T">Need to Object</typeparam>
 7     public class ObjectPoolFactory<T> where T : ObjectPoolBase, new()
 8     {
 9         // Maximum objects allowed!
         private static int _PoolMaxSize = 2;
 
         // My Collection Pool 
         private static readonly Queue<T> objPool = new Queue<T>(_PoolMaxSize);
 
         /// <summary>
         /// Gets the object from pool.
         /// </summary>
         /// <returns>ObjectPoolBase</returns>
         public ObjectPoolBase GetObjectFromPool<T>()
         {
             ObjectPoolBase objectt = null;
             // check from the collection pool. If exists return object else create new
             if (ObjectPoolBase.Counter >= _PoolMaxSize && objPool.Count > 0)
             {
                 // Retrieve from pool
                 objectt = RetrieveFromPool<T>();
             }
             else
             {
                 objectt = GetNewObject();
             }
             return objectt;
         }
 
         /// <summary>
         /// Gets the new object.
         /// </summary>
         /// <returns>ObjectPoolBase</returns>
         private ObjectPoolBase GetNewObject()
         {
             // Creates a new object
             T t1 = new T();
             objPool.Enqueue(t1);
             return t1;
         }
 
         /// <summary>
         /// Retrieves from pool.
         /// </summary>
         /// <returns>ObjectPoolBase</returns>
         protected ObjectPoolBase RetrieveFromPool<T>()
         {
             ObjectPoolBase object1;
             // if there is any objects in my collection
             if (objPool.Count > 0)
             {
                 object1 = (ObjectPoolBase)objPool.Dequeue();
                 ObjectPoolBase.Counter--;
             }
             else
             {
                 // return a new object
                 object1 = new ObjectPoolBase();
             }
             return object1;
         }
     }

对于目标对象就继承ObjectPoolBase:

 1   public class Parent : ObjectPoolBase
 2     {
 3 
 4         #region Constructors (1) 
 5 
 6         public Parent()
 7         {
 8             Console.WriteLine("Parent Ctor");
 9         }
 
         #endregion Constructors 
 
         #region Methods (1) 
 
         public virtual void Print()
         {
             Console.WriteLine("Parent Print");
         }
 
         #endregion Methods 
     }

如何使用，看下面代码：

         [Test]
         public void ObjectPoolFactoryForGeneric()
         {
             ObjectPoolFactory<Parent> poo = new ObjectPoolFactory<Parent>();
             Parent Parent1 = poo.GetObjectFromPool<Parent>() as Parent;
             Console.WriteLine("First object");
             Parent Parent2 = poo.GetObjectFromPool<Parent>() as Parent;
             Console.WriteLine("Second object");
         }