sdk/samples/WCFSamples/TechnologySamples/Extensibility/Instancing/Pooling/CS/extensions/ObjectPoolInstanceProvider.cs

   1 using System;
   2 using System.Collections;
   3 using System.Collections.Generic;
   4 using System.Reflection;
   5 using System.ServiceModel;
   6 using System.ServiceModel.Channels;
   7 using System.ServiceModel.Dispatcher;
   8 using System.Threading;
   9 using System.Timers;
  10 using Timer = System.Timers.Timer;
  11
  12 namespace Microsoft.ServiceModel.Samples
  13 {
  14     // This class contains the implementation for the object pool. This implements the
  15     // IInstanceProvider interface in order to be able to plugin to the dispatcher layer.
  16     class ObjectPoolingInstanceProvider : IInstanceProvider
  17     {
  18         const int idleTimeout = 5 * 60 * 1000;     // 5 minutes
  19
  20         #region Private Fields
  21
  22         // Minimum number of objects in the pool
  23         int minPoolSize;
  24
  25         // Type of the object created in the pool
  26         Type instanceType;
  27
  28         // Stack used for storing objects in the pool
  29         Stack<object> pool;
  30
  31         // Lock should acquired before accessing the pool stack
  32         object poolLock = new object();
  33
  34         // Keeps track of the number of objects returned from the pool.
  35         int activeObjectsCount;
  36
  37         // Timer object used to trigger the clean up process
  38         // after a given period of idle time.
  39         Timer idleTimer;
  40
  41         #endregion
  42
  43         public ObjectPoolingInstanceProvider(Type instanceType, int minPoolSize)
  44         {
  45             this.minPoolSize = minPoolSize;
  46             this.instanceType = instanceType;
  47
  48             pool = new Stack<object>();
  49             activeObjectsCount = 0;
  50
  51             // Initialize the timer and subscribe to the "Elapsed" event
  52             idleTimer = new Timer(idleTimeout);
  53             idleTimer.Elapsed += new System.Timers.ElapsedEventHandler(idleTimer_Elapsed);
  54
  55             // Initialize the minimum number of objects if possible
  56             Initialize();
  57         }
  58
  59         #region IInstanceProvider Members
  60
  61         object IInstanceProvider.GetInstance(InstanceContext instanceContext)
  62         {
  63             return ((IInstanceProvider)this).GetInstance(instanceContext, null);
  64         }
  65
  66         object IInstanceProvider.GetInstance(InstanceContext instanceContext, Message message)
  67         {
  68             object obj = null;
  69
  70             lock (poolLock)
  71             {
  72                 if (pool.Count > 0)
  73                 {
  74                     obj = pool.Pop();
  75                 }
  76                 else
  77                 {
  78                     obj = CreateNewPoolObject();
  79                 }
  80                 activeObjectsCount++;
  81             }
  82
  83             WritePoolMessage(ResourceHelper.GetString("MsgNewObject"));
  84
  85             idleTimer.Stop();
  86
  87             return obj;
  88         }
  89
  90         void IInstanceProvider.ReleaseInstance(InstanceContext instanceContext, object instance)
  91         {
  92             lock (poolLock)
  93             {
  94                 pool.Push(instance);
  95                 activeObjectsCount--;
  96
  97                 WritePoolMessage(ResourceHelper.GetString("MsgObjectPooled"));
  98
  99                 // When the service goes completely idle (no requests are being processed),
 100                 // the idle timer is started
 101                 if (activeObjectsCount == 0)
 102                     idleTimer.Start();
 103             }
 104         }
 105
 106         #endregion
 107
 108         // Initialize the pool with minimum number of instances
 109         void Initialize()
 110         {
 111             for (int i = 0; i < minPoolSize; i++)
 112             {
 113                 pool.Push(CreateNewPoolObject());
 114             }
 115         }
 116
 117         // Handles the instantiation of the types created by this instance
 118         private object CreateNewPoolObject()
 119         {
 120             return Activator.CreateInstance(instanceType);
 121         }
 122
 123         // Clean up procedure
 124         void idleTimer_Elapsed(object sender, ElapsedEventArgs args)
 125         {
 126             idleTimer.Stop();
 127
 128             lock (poolLock)
 129             {
 130                 if (activeObjectsCount == 0)
 131                 {
 132                     while (pool.Count > minPoolSize)
 133                     {
 134                         WritePoolMessage(ResourceHelper.GetString("MsgObjectRemoving"));
 135
 136                         object removedItem = pool.Pop();
 137
 138                         if (removedItem is IDisposable)
 139                         {
 140                             ((IDisposable)removedItem).Dispose();
 141                         }
 142                     }
 143                 }
 144             }
 145         }
 146
 147         // Writes a given message to the console in red color
 148         void WritePoolMessage(string message)
 149         {
 150             ConsoleColor currentForegroundColor = Console.ForegroundColor;
 151             Console.ForegroundColor = ConsoleColor.Red;
 152             Console.WriteLine(message);
 153             Console.ForegroundColor = currentForegroundColor;
 154         }
 155     }
 156 }