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
}