class Program : IObjectFactory<PoolableObject> {
    static void Main(string[] args) {
      new Program( ).Run( );
    }
	
    Pool<PoolableObject> pool;
    private const int threadCount = 3;
	
    void Run( ) {
      pool = new Pool<PoolableObject>(this, 0);
      pool.UseTimerBasedResizing = true;
      pool.MaxPoolSize = 100;
	
      Thread[] threads = new Thread[threadCount];
      for (int i = 0; i < threadCount; i++) {
        threads[i] = new Thread(new ThreadStart(ThreadMethod));
        threads[i].Start( );
      }
	
      while (true) {
        Console.WriteLine("Current pool size: " + pool.Size);
        Thread.Sleep(2000);
      }
    }
	
    void ThreadMethod( ) {
      Random random = new Random( );
      while (true) {
        if (random.Next(0, 100) > 50) {
          // boost
          int boostSize = random.Next(5, 20);
          PoolableObject[] objects = new PoolableObject[boostSize];
          for (int i = 0; i < boostSize; i++) {
            objects[i] = pool.GetObject( );
            Console.WriteLine(String.Format("Thread {0} allocated object {1}.",
              Thread.CurrentThread.ManagedThreadId, objects[i].Id));
            objects[i].DoWork( );
          }
          Thread.Sleep(random.Next(0, 5000));
          for (int i = 0; i < boostSize; i++) {
            pool.ReleaseObject(objects[i]);
            Console.WriteLine(String.Format("Thread {0} released object {1}.",
              Thread.CurrentThread.ManagedThreadId, objects[i].Id));
          }
        }
        else {
          // single
          PoolableObject poolableObject = pool.GetObject( );
          Console.WriteLine(String.Format("Thread {0} allocated object {1}.",
            Thread.CurrentThread.ManagedThreadId, poolableObject.Id));
          poolableObject.DoWork( );
          Thread.Sleep(random.Next(0, 5000));
          pool.ReleaseObject(poolableObject);
          Console.WriteLine(String.Format("Thread {0} released object {1}.",
            Thread.CurrentThread.ManagedThreadId, poolableObject.Id));
        }
      }
    }
	
    #region IObjectFactory<PoolableObject> Members
    PoolableObject IObjectFactory<PoolableObject>.CreateObject( ) {
        return new PoolableObject( );
    }
    #endregion
  }
	
  public class PoolableObject {
    public PoolableObject( ) {
      id = Guid.NewGuid( );
      Console.WriteLine(String.Format("Poolable object {0} is being constructed.", id));
    }
	
    ~PoolableObject( ) {
      Console.WriteLine(String.Format("Poolable object {0} is being destructed.", id));
    }
	
    private Guid id;
    public Guid Id {
      get {
        return id;
      }
    }
	
    int useCount;
	
    public void DoWork( ) {
      // Obviously this object should be able to actually do something, but
      // that's not relevant to the test program.
      // So we just count how many times an object has been used.
      Console.WriteLine(String.Format("Poolable object {0} has been used {1} times now.", id, ++useCount));
    }
  }

class Pool<T> {
  . . .
	
  private Pool( ) {
    pool = new List<Slot>( );
    retryWaitTime = 500;
    poolExtensionBatchSize = 10;
    poolExtensionBatchSizeIsPercent = true;
    maxGetObjectTries = 5;
    outOfObjectsBehaviour = OutOfObjectsBehaviour.ExtendPool;
    delayObjectCreation = false;
    maxPoolSize = 100;
    lowWaterMark = 20;
    highWaterMark = 80;
    resizingWaitTime = 2000;
    growThreshold = 0;
    shrinkThreshold = 3;
  }
	
  Timer resizingTimer;
  object resizingTimerLock = new object( );
	
  private bool useTimerBasedResizing;
  /// 

  /// Gets or sets a value indicating whether the pool checks for low and high
  /// water situations automatically and regularly. Also see ResizingWaitTime.
  /// 
  public bool UseTimerBasedResizing {
    get {
      return useTimerBasedResizing;
    }
    set {
      if (useTimerBasedResizing != value) {
        useTimerBasedResizing = value;
        lock (resizingTimerLock) {
          if (useTimerBasedResizing == false && resizingTimer != null)
            resizingTimer.Dispose( );
          else if (useTimerBasedResizing == true)
            resizingTimer = new Timer(new TimerCallback(ResizingTimerCallback),
              null, resizingWaitTime, Timeout.Infinite);
        }
      }
    }
  }
	
  private int resizingWaitTime;
  /// 

  /// Gets or sets a value that indicates the time between to checks for low and
  /// high water situations. Also see UseTimerBasedResizing.
  /// 
  public int ResizingWaitTime {
    get {
      return resizingWaitTime;
    }
    set {
      if (resizingWaitTime != value) {
        resizingWaitTime = value;
        lock (resizingTimerLock) {
          if (resizingTimer != null)
            resizingTimer.Change(resizingWaitTime, Timeout.Infinite);
        }
      }
    }
  }
	
  private int highWaterMark;
  /// 

  /// Gets or sets a value indicating the percentage of used objects in the pool
  /// that must be exceeded for the pool to be grown automatically.
  /// 
  public int HighWaterMark {
    get {
      return highWaterMark;
    }
    set {
      if (highWaterMark != value) {
        highWaterMark = value;
      }
    }
  }
	
  private int lowWaterMark;
  /// 

  /// Gets or sets a value that the percentage of used objects in the pool
  /// must fall below for the pool to be shrunken automatically.
  /// 
  public int LowWaterMark {
    get {
      return lowWaterMark;
    }
    set {
      if (lowWaterMark != value) {
        lowWaterMark = value;
      }
    }
  }
	
  private int shrinkThreshold;
  /// 

  /// Gets or sets a value indicating the number of times the pool must
  /// be judged too big before it is shrunken.
  /// 
  public int ShrinkThreshold {
    get {
      return shrinkThreshold;
    }
    set {
      if (shrinkThreshold != value) {
        shrinkThreshold = value;
      }
    }
  }
	
  private int growThreshold;
  /// 

  /// Gets or sets a value indicating the number of times the pool must
  /// be judged too small before it is grown.
  /// 
  public int GrowThreshold {
    get {
      return growThreshold;
    }
    set {
      if (growThreshold != value) {
        growThreshold = value;
      }
    }
  }
	
  Slot FindUnusedSlot( ) {
    return pool.Find(delegate(Slot slot) {
      return !slot.InUse;
    });
  }
	
  /// 

  /// Shrinks the pool size by count elements, at most. The method removes
  /// only unused pool objects, as long as it finds them.
  /// 
  public void ShrinkPoolBy(int count) {
    if (count < = 0)
      throw new ArgumentOutOfRangeException("Count must be greater than zero.");
    lock (poolLock) {
      count = Math.Max(pool.Count - count, 0);
	
      Slot unusedSlot;
      do {
        unusedSlot = FindUnusedSlot( );
        if (unusedSlot != null)
          pool.Remove(unusedSlot);
        count--;
      } while (count > 0 && unusedSlot != null);
    }
  }
	
  /// 

  /// Returns the number of used objects in the pool.
  /// 
  public int GetInUseCount( ) {
    int count = 0;
    pool.ForEach(delegate(Slot slot) {
      if (slot.InUse)
      count++;
    });
    return count;
  }
	
  /// 

  /// Returns the percentage of used objects in the pool.
  /// 
  public int GetFillLevel( ) {
    return GetInUseCount( ) / pool.Count * 100;
  }
	
  int fillLevelFoundTooLow;
  int fillLevelFoundTooHigh;
	
  void ResizingTimerCallback(object state) {
    int fillLevel = GetFillLevel( );
	
    if (fillLevel < lowWaterMark) {
      fillLevelFoundTooLow++;
      fillLevelFoundTooHigh = 0;
    }
    else if (fillLevel > highWaterMark) {
      fillLevelFoundTooHigh++;
      fillLevelFoundTooLow = 0;
    }
    else
      fillLevelFoundTooHigh = fillLevelFoundTooLow = 0;
	
    if (fillLevelFoundTooLow > shrinkThreshold) {
      ShrinkPoolBy(lowWaterMark - fillLevel);
      fillLevelFoundTooLow = 0;
    }
    else if (fillLevelFoundTooHigh > growThreshold) {
      ExtendPoolBy(fillLevel - highWaterMark);
      fillLevelFoundTooHigh = 0;
    }
	
    lock (resizingTimerLock)
      if (resizingTimer != null)
        resizingTimer.Change(resizingWaitTime, Timeout.Infinite);
  }
	
  . . .
}

public T GetObject( ) {
  int tryNo = 1;
	
  while(tryNo <= maxGetObjectTries) {
    lock (poolLock) {
      Slot unusedSlot = pool.Find(delegate(Slot slot) {
        return !slot.InUse;
      });
      if (unusedSlot != null) {
        unusedSlot.Occupy( );
        return unusedSlot.PoolObject;
      }
    }
	
    switch (outOfObjectsBehaviour) {
      case OutOfObjectsBehaviour.ReturnNull:
        return default(T);
      case OutOfObjectsBehaviour.ThrowException:
        throw new OutOfObjectsException( );
      case OutOfObjectsBehaviour.WaitAndRetry:
        Thread.Sleep(retryWaitTime);
        break;
      case OutOfObjectsBehaviour.ExtendPool:
        ExtendPool( );
        break;
    }
  }
	
  throw new OutOfObjectsException( );
}

  /// 

  /// Extends the pool by a number of objects that's specified by the PoolExtensionBatchSize
  /// and the PoolExtensionBatchSizeIsPercent properties.
  /// 
  void ExtendPool( ) {
    lock (poolLock) {
      int newObjects = poolExtensionBatchSizeIsPercent ?
        pool.Count * poolExtensionBatchSize / 100 : poolExtensionBatchSize;
      ExtendPoolBy(newObjects);
    }
  }

class Pool {
  . . .
  private int maxPoolSize;
  /// 

  /// Gets or sets a value indicating the maximum number of objects that the pool
  /// shall hold. The ExtendPoolBy() method won't extend the pool to a larger
  /// size than this.
  /// 
  public int MaxPoolSize {
    get {
      return maxPoolSize;
    }
    set {
      if (maxPoolSize != value) {
        maxPoolSize = value;
        lock (poolLock) {
          // This might be replaced by a call to the proper shrinking
          // method later.
          if (pool.Count > maxPoolSize)
            pool.RemoveRange(maxPoolSize, pool.Count - maxPoolSize);
        }
      }
    }
  }
	
  private int maxGetObjectTries;
  /// 

  /// Gets or sets a value that defines the maximum tries that are made
  /// to acquire an object from the pool in the GetObject() method.
  /// 
  public int MaxGetObjectTries {
    get {
      return maxGetObjectTries;
    }
    set {
      if (maxGetObjectTries != value) {
        maxGetObjectTries = value;
      }
    }
  }
	
  private int poolExtensionBatchSize;
  /// 

  /// Gets or sets a value that defines the size of the batch when the pool is
  ///  growing. This can be an absolute value or a percentage, which is
  /// defined by the PoolExtensionBatchSizeIsPercent property.
  /// 
  public int PoolExtensionBatchSize {
    get {
      return poolExtensionBatchSize;
    }
    set {
      if (poolExtensionBatchSize != value) {
        poolExtensionBatchSize = value;
      }
    }
  }
	
  private bool poolExtensionBatchSizeIsPercent;
  /// 

  /// Gets or sets a flag that indicates whether the value given by
  /// the PoolExtensionBatchSize property is an absolute value or a percentage.
  /// 
  public bool PoolExtensionBatchSizeIsPercent {
    get {
      return poolExtensionBatchSizeIsPercent;
    }
    set {
      if (poolExtensionBatchSizeIsPercent != value) {
        poolExtensionBatchSizeIsPercent = value;
      }
    }
  }
	
  private int retryWaitTime;
  /// 

  /// Gets or sets a value that defines the time to wait between tries
  /// to acquire a pool object in the GetObject() method. This is only
  /// evaluated for OutOfObjectsBehaviour == WaitAndRetry.
  /// 
  public int RetryWaitTime {
    get {
      return retryWaitTime;
    }
    set {
      if (retryWaitTime != value) {
        retryWaitTime = value;
      }
    }
  }
	
  private OutOfObjectsBehaviour outOfObjectsBehaviour;
  /// 

  /// Gets or sets a value indicating the behaviour that the GetObject()
  /// method shows when a pool object isn't (immediately) available.
  /// 
  public OutOfObjectsBehaviour OutOfObjectsBehaviour {
    get {
      return outOfObjectsBehaviour;
    }
    set {
      if (outOfObjectsBehaviour != value) {
        outOfObjectsBehaviour = value;
      }
    }
  }
  . . .
}
	
/// 

/// Defines the possible behaviours that the GetObject()
/// method can shows when a pool object isn't (immediately) available.
/// 
public enum OutOfObjectsBehaviour {
  /// 

  /// Return null or the default value of the type.
  /// 
  ReturnNull,
  /// 

  /// Wait for a time specified by the Pool.RetryWaitTime property and try again.
  /// A maximum number of tries is specified by the Pool.MaxGetObjectTries
  /// property.
  /// 
  WaitAndRetry,
  /// 

  /// Throw an OutOfObjectsException.
  /// 
  ThrowException,
  /// 

  /// Extend the pool by a default batch as defined by the
  /// Pool.PoolExtensionBatchSize and Pool.PoolExtensionBatchSizeIsPercent
  /// properties, then try again. A maximum number of tries is specified by
  /// the Pool.MaxGetObjectTries property.
  /// 
  ExtendPool
}

public interface IObjectFactory<T> {
  T CreateObject( );
}

class Slot {
  . . .
  /// 

  /// Constructs a Slot object without a pre-existing pooled type object.
  /// Creation of the pooled type object will be deferred to the point
  /// where the object is actually accessed via the PoolObject property.
  /// 
  public Slot(IObjectFactory<T> objectFactory) {
    if (objectFactory == null)
      throw new ArgumentNullException("objectFactory");
    this.objectFactory = objectFactory;
  }
	
  IObjectFactory<T> objectFactory;
  T poolObject;
	
  /// 

  /// Returns the pooled object itself. If there isn't any object yet,
  /// it'll be created on the fly using the object factory.
  /// 
  public T PoolObject {
    get {
      if (poolObject == null)
        poolObject = objectFactory.CreateObject( );
      return poolObject;
    }
  }
  . . .
}
	
class Pool {
  . . .
  /// 

  /// Creates a new Pool object. The list of objects in the pool is
  /// expanded by a number of additional slots, as given by the
  /// initialPoolSize parameter. Objects are created by a call to the
  /// IObjectFactory<T>.CreateObject() method.
  /// 
  public Pool(IObjectFactory<T> objectFactory, int initialPoolSize) : this( ) {
    this.objectFactory = objectFactory;
    if (initialPoolSize > 0)
      ExtendPoolBy(initialPoolSize);
  }
	
  private IObjectFactory<T> objectFactory;
  /// 

  /// Gets or sets a value defining the object factory that can be used
  /// by the pool to create new poolable objects as necessary.
  /// 
  public IObjectFactory<T> ObjectFactory {
    get {
      return objectFactory;
    }
    set {
      if (objectFactory != value) {
        objectFactory = value;
      }
    }
  }
	
  private bool delayObjectCreation;
  /// 

  /// Gets or sets a flag that defines whether a poolable type object is
  /// immediately created together with a new Slot, or whether the
  /// creation of the poolable type object will be delayed.
  /// 
  public bool DelayObjectCreation {
    get {
      return delayObjectCreation;
    }
    set {
      if (delayObjectCreation != value) {
        delayObjectCreation = value;
      }
    }
  }
	
  /// 

  /// Extends the number of slots in the pool by the number given in
  /// the count parameter.
  /// 
  public void ExtendPoolBy(int count) {
    if (objectFactory == null)
      throw new InvalidOperationException("An ObjectFactory must be configured.");
    if (count <= 0)
      throw new ArgumentOutOfRangeException("Count must be greater than zero.");
    lock (poolLock) {
      count = Math.Min(maxPoolSize - pool.Count, count);
	
      for (int i = 0; i < count; i++) {
        Slot slot = delayObjectCreation ? new Slot(objectFactory) :
          new Slot(objectFactory.CreateObject( ));
        pool.Add(slot);
      }
    }
  }
  . . .
}

class Slot {
  . . .
  /// 

  /// Constructs a Slot object for a pre-existing pooled type object.
  /// 
  public Slot(T poolObject) {
    if (poolObject == null)
      throw new ArgumentNullException("poolObject");
    this.poolObject = poolObject;
  }
  . . .
}
	
class Pool {
  . . .
  private Pool( ) {
    pool = new List<Slot>( );
  }
	
  /// 

  /// Constructs a pool and fills its list of pooled objects with the objects
  /// passed in to this constructor.
  /// 
  public Pool(IEnumerable<T> objects) : this( ) {
    foreach (T entry in objects)
      pool.Add(new Slot(entry));
  }
  . . .
}

class Pool {
  . . .
  object poolLock = new object( );
	
  /// 

  /// Returns a pooled object. After use, the pooled object must be returned to the
  /// pool by calling the ReleaseObject method.
  /// 
  public T GetObject( ) {
    lock (poolLock) {
      Slot unusedSlot = pool.Find(delegate(Slot slot) {
        return !slot.InUse;
      });
      if (unusedSlot != null) {
        unusedSlot.Occupy( );
        return unusedSlot.PoolObject;
      }
    }
    throw new OutOfObjectsException( );
  }
	
  /// 

  /// Releases an object that was previously fetched from the pool
  /// by a call to the GetObject method.
  /// 
  public void ReleaseObject(T poolObject) {
    lock (poolLock) {
      Slot objectSlot = pool.Find(delegate(Slot slot) {
        return EqualityComparer<T>.Default.Equals(slot.Object, poolObject);
      });
      if (objectSlot != null)
        objectSlot.Release( );
      else
        throw new ArgumentException("The given object is not part of this pool.");
    }
  }
  . . .
}
	
class Slot {
  . . .
  /// 

  /// Marks the slot as being in use.
  /// 
  public void Occupy( ) {
    inUse = true;
  }
	
  /// 

  /// Marks the slot as being available.
  /// 
  public void Release( ) {
    inUse = false;
  }
  . . .
}
	
[Serializable]
public class OutOfObjectsException : Exception {
  public OutOfObjectsException( ) { }
  public OutOfObjectsException(string message) : base(message) { }
  public OutOfObjectsException(string message, Exception innerException) : base(message, innerException) { }
  protected OutOfObjectsException(SerializationInfo info, StreamingContext context) : base(info, context) { }
}

/// 

/// This is the main Pool class, which implements object pooling.
/// 
public sealed class Pool<T> {
  /// 

  /// The slot class represents an entry in the pool's list. It holds information about
  /// the actual pooled object, plus per-object management information.
  /// 
  sealed class Slot {
    T poolObject;
    /// 

    /// Returns the pooled object itself.
    /// 
    public T PoolObject {
      get {
        return poolObject;
      }
    }
	
    bool inUse;
    /// 

    /// Returns a value indicating whether this slot is currently in use or not, in other words
    /// whether its object has been reserved for use at this time.
    /// 
    public bool InUse {
      get {
        return inUse;
      }
    }
  }
	
  List<Slot> pool;
	
  /// 

  /// Returns a pooled object. After use, the pooled object must be returned to the
  /// pool by calling the ReleaseObject method.
  /// 
  public T GetObject( ) {
  }
	
  /// 

  /// Releases an object that was previously fetched from the pool
  /// by a call to the GetObject method.
  /// 
  public void ReleaseObject(T poolObject) {
  }
}