private string performanceCategoryName;
/// <summary>
/// Gets or sets a value indicating the name of the performance counter category.
/// </summary>
public string PerformanceCategoryName {
  get {
    return performanceCategoryName;
  }
  set {
    if (performanceCategoryName != value) {
      performanceCategoryName = value;
      InvalidateCounters( );
    }
  }
}
	
private string performanceCounterNamePrefix;
/// <summary>
/// Gets or sets a value indicating a prefix that is used for all the performance
/// counters of this pool instance.
/// </summary>
public string PerformanceCounterNamePrefix {
  get {
    return performanceCounterNamePrefix;
  }
  set {
    if (performanceCounterNamePrefix != value) {
      performanceCounterNamePrefix = value;
      InvalidateCounters( );
    }
  }
}
	
/// <summary>
/// Set the properties PerformanceCategoryName and PerformanceCounterNamePrefix to the values
/// passed in to the categoryName and counterNamePrefix parameters, then calls InitializeCounters().
/// </summary>
public void InitializeCounters(string categoryName, string counterNamePrefix) {
  performanceCategoryName = categoryName;
  performanceCounterNamePrefix = counterNamePrefix;
  InitializeCounters( );
}
	
private const string STR_Poolsize = "Pool size";
private const string STR_PoolsizeHelp = "The current number of poolable objects.";
private const string STR_ObjectsInUse = "Objects in use";
private const string STR_ObjectsInUseHelp =
  "The number of objects that are currently allocated to a pool user.";
	
PerformanceCounter poolSizeCounter;
PerformanceCounter inUseCounter;
	
/// <summary>
/// Initializes the performance counters according to the settings of the PerformanceCategoryName
/// and PerformanceCounterNamePrefix properties.
/// </summary>
public void InitializeCounters( ) {
  if (PerformanceCounterCategory.Exists(performanceCategoryName))
    PerformanceCounterCategory.Delete(performanceCategoryName);
	
  CounterCreationDataCollection counters = new CounterCreationDataCollection( );
	
  counters.Add(new CounterCreationData(performanceCounterNamePrefix + STR_Poolsize,
    STR_PoolsizeHelp, PerformanceCounterType.NumberOfItems32));
  counters.Add(new CounterCreationData(performanceCounterNamePrefix + STR_ObjectsInUse,
    STR_ObjectsInUseHelp, PerformanceCounterType.NumberOfItems32));
	
  PerformanceCounterCategory.Create(performanceCategoryName, "",
    PerformanceCounterCategoryType.SingleInstance, counters);
	
  poolSizeCounter = new PerformanceCounter(performanceCategoryName,
    performanceCounterNamePrefix + STR_Poolsize, false);
  inUseCounter = new PerformanceCounter(performanceCategoryName,
    performanceCounterNamePrefix + STR_ObjectsInUse, false);
}
	
void InvalidateCounter(ref PerformanceCounter counter) {
  if (counter != null) {
    counter.Dispose( );
    counter = null;
  }
}
	
void InvalidateCounters( ) {
  InvalidateCounter(ref poolSizeCounter);
  InvalidateCounter(ref inUseCounter);
}

  . . .
  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);
    }
	
    if (poolSizeCounter != null)
      poolSizeCounter.RawValue = pool.Count;
  }
  . . .

  . . .
  if (poolSizeCounter != null)
    poolSizeCounter.RawValue = pool.Count;
  . . .