View difference between Paste ID: V8ijvNeH and iPYWN1SZ

-internal class ResourcePool : IDisposable
+using System;
 using System.Linq;
-    private TimerCallback _callback;
+using System.Collections.Concurrent;
-    private bool _disposed;
+using System.Diagnostics;
-    private int _iDisposable;
+using System.Threading;
-    private TimeSpan _interval;
+using Core.Threading;
-    private int _max;
+
-    private ArrayList _resources;
+namespace ConsoleApplication1
-    private Timer _timer;
+
     class ResourcePoolExample
-    internal ResourcePool(TimeSpan interval, int max)
+
 
-        this._interval = interval;
+        static void Main()
-        this._resources = new ArrayList(4);
+
-        this._max = max;
+
-        this._callback = new TimerCallback(this.TimerProc);
+            ExpensiveResource.InstanceCount = 0;
 
             int threadCount = 25;
-    [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
+            int maxInstances = 2;
-    public void Dispose()
+
             int min = threadCount- 2;
-        this.Dispose(true);
+
             ThreadPool.SetMinThreads(min, min);
             //create factory to create ExpensiveResource instances
-    private void Dispose(bool disposing)
+            Func<ExpensiveResource> factory = () =>
             {
-        lock (this)
+                return new ExpensiveResource();
             };
-            if (!this._disposed)
+
             ResourcePool<ExpensiveResource> pool = new ResourcePool<ExpensiveResource>(maxInstances, factory, 5000);
-                if (this._resources != null)
+
             //event to signal when all threads are started
-                    foreach (IDisposable disposable in this._resources)
+            CountdownEvent allStarted = new CountdownEvent(threadCount);
-                    {
+
-                        disposable.Dispose();
+            //event to signal when all threads are complete
-                    }
+            CountdownEvent allEnded = new CountdownEvent(threadCount);
-                    this._resources.Clear();
+
             //event to signal all threads to go
-                if (this._timer != null)
+            ManualResetEventSlim goevent = new ManualResetEventSlim(false);
 
-                    this._timer.Dispose();
+            //Action that runs in every thread
             Action<int> testAction = (id) =>
-                this._disposed = true;
+
-                if (disposing)
+
                 string indent = "".PadLeft(id, '-');
-                    GC.SuppressFinalize(this);
+
                 //signal this thread has started
                 allStarted.Signal();
                 Console.Write(".");
                 //wait for every thread
                 goevent.Wait();
-    ~ResourcePool()
+
                 //delay each thread to simulate reality.
-        this.Dispose(false);
+                Random rnd = new Random(Guid.NewGuid().ToString().GetHashCode());
                 Thread.Sleep(rnd.Next(10, 100));
 
-    internal object RetrieveResource()
+                ExpensiveResource resource = null;
 
-        object obj2 = null;
+
-        if (this._resources.Count != 0)
+
 
-            lock (this)
+                    //we grab our resource
                     resource = pool.Take();
-                if (this._disposed)
+
                     Console.WriteLine(indent + "Action{0} Take -> Instance_{1}", id, resource.InstanceId);
-                    return obj2;
+
                     //execute process
-                if (this._resources.Count == 0)
+                    resource.ExpensiveProcess();
 
-                    return null;
+
                 catch (Exception error)
-                obj2 = this._resources[this._resources.Count - 1];
+
-                this._resources.RemoveAt(this._resources.Count - 1);
+                    Console.WriteLine("ERROR ExpensiveProcess: {0}", error.Message);
-                if (this._resources.Count < this._iDisposable)
+
                 finally
-                    this._iDisposable = this._resources.Count;
+
                     //return our resource to the pool when finished
                     pool.Return(resource);
                     Console.WriteLine(indent + "Action{0} Return -> Instance_{1}", id, resource.InstanceId);
-        return obj2;
+
                     //signal when finished
                     allEnded.Signal();
-    internal void StoreResource(IDisposable o)
+
             };
-        lock (this)
+
             Console.WriteLine("Starting {0:N0} threads", threadCount);
-            if (!this._disposed && (this._resources.Count < this._max))
+
             //create our worker threads
-                this._resources.Add(o);
+            for (int i = 0; i < threadCount; i++)
-                o = null;
+
-                if (this._timer == null)
+                int workerId = i + 1;
 
-                    this._timer = new Timer(this._callback, null, this._interval, this._interval);
+                ThreadPool.QueueUserWorkItem((state) =>
                 {
                     testAction((int)state);
                 }, workerId);
-        if (o != null)
+
 
-            o.Dispose();
+
             Console.WriteLine();
 
             //wait for all threads  to startup
-    private void TimerProc(object userData)
+            allStarted.Wait();
             Console.WriteLine();
-        IDisposable[] array = null;
+            Console.WriteLine("All {0:N0} threads have started",threadCount);
-        lock (this)
+            //fire off all threads
             goevent.Set();
-            if (!this._disposed)
+
             //wait until all threads are completed
-                if (this._resources.Count == 0)
+            allEnded.Wait();
 
-                    if (this._timer != null)
+            //uncomment to use 'Parallel lib'
-                    {
+            //Parallel.For(0,threadCount,testAction);
-                        this._timer.Dispose();
+
-                        this._timer = null;
+            Console.WriteLine();
-                    }
+            Console.WriteLine("threadCount {0}", threadCount);
-                    return;
+            Console.WriteLine("pool.MaxInstances: {0}", pool.MaxInstances);
             Console.WriteLine("pool.InstancesCreated: {0}", pool.InstancesCreated);
-                array = new IDisposable[this._iDisposable];
+            Console.WriteLine("ExpensiveResource.InstanceCount: {0}", ExpensiveResource.InstanceCount);
-                this._resources.CopyTo(0, array, 0, this._iDisposable);
+            Console.WriteLine("pool.Count: {0}", pool.Count);
-                this._resources.RemoveRange(0, this._iDisposable);
+            Console.WriteLine();
-                this._iDisposable = this._resources.Count;
+            Console.WriteLine("Test Finished");
         }
     }
-        if (array != null)
+    class ExpensiveResource
     {
-            for (int i = 0; i < array.Length; i++)
+
         //global instances created
         public static int InstanceCount;
 
-                    array[i].Dispose();
+        //resource id
         public int InstanceId { get; private set; }
-                catch
+
         public ExpensiveResource()
         {
 
             InstanceId = Interlocked.Increment(ref InstanceCount);
             Console.WriteLine("Created Instance #: {0}", InstanceId);
         }
 
         public void ExpensiveProcess()
         {
             //simulate long process
             Random rnd = new Random(Guid.NewGuid().ToString().GetHashCode());
             int st = rnd.Next(500, 1000);
             Thread.Sleep(st);
         }
     }
 }
 
 
 namespace Core.Threading {
 
     /// <summary>
     /// Resource pool that uses a <see cref="System.Collections.Concurrent.BlockingCollection<T>"/> that limits the use of specified resource.
     /// If an item in the pool is requested and the instance count is under the maximum a new instance of the resource is created via <see cref="Func<T>"/> parameter.
     /// </summary>
     /// <example>
     /*
          class ResourcePoolExample {
 
         static void Main() {
 
             ExpensiveResource.InstanceCount = 0;
 
             int threadCount = 8;
             int maxInstances = 2;
 
             //create factory to create ExpensiveResource instances
             Func<ExpensiveResource> factory = () => {
                 return new ExpensiveResource();
             };
 
             ResourcePool<ExpensiveResource> pool = new ResourcePool<ExpensiveResource>(maxInstances,factory,5000);
 
             //event to signal when all threads are complete
             CountdownEvent cde = new CountdownEvent(threadCount);
 
             //event to signal all threads to go
             ManualResetEventSlim goevent = new ManualResetEventSlim(false);
 
             //Action that runs in every thread
             Action<int> testAction = (id) => {
 
                 string indent = "".PadLeft(id,'-');
 
                 //wait for every thread
                 goevent.Wait();
 
                 //delay each thread to simulate reality.
                 Random rnd = new Random(Guid.NewGuid().ToString().GetHashCode());
                 Thread.Sleep(rnd.Next(10,100));
 
                 ExpensiveResource resource = null;
 
                 try {
 
                     //we grab our resource
                     resource = pool.Take();
 
                     Console.WriteLine(indent + "Action{0} Take -> Instance_{1}",id,resource.InstanceId);
 
                     //execute process
                     resource.ExpensiveProcess();
 
                 }
                 catch(Exception error) {
                     Console.WriteLine("ERROR ExpensiveProcess: {0}",error.Message);
                 }
                 finally {
                     //return our resource to the pool when finished
                     pool.Return(resource);
                     Console.WriteLine(indent + "Action{0} Return -> Instance_{1}",id,resource.InstanceId);
 
                     //signal when finished
                     cde.Signal();
                 }
             };
 
             //create our worker threads
             for(int i = 0;i < threadCount;i++) {
                 int workerId = i + 1;
 
                 ThreadPool.QueueUserWorkItem((state) => {
                     testAction((int)state);
                 },workerId);
             }
 
             Thread.Sleep(10);
 
             //fire off all threads
             goevent.Set();
 
             //wait until all threads are completed
             cde.Wait();
 
             //uncomment to use 'Parallel lib'
             //Parallel.For(0,threadCount,testAction);
 
             Console.WriteLine();
             Console.WriteLine("threadCount {0}",threadCount);
             Console.WriteLine("pool.MaxInstances: {0}",pool.MaxInstances);
             Console.WriteLine("pool.InstancesCreated: {0}",pool.InstancesCreated);
             Console.WriteLine("ExpensiveResource.InstanceCount: {0}",ExpensiveResource.InstanceCount);
             Console.WriteLine("pool.Count: {0}",pool.Count);
             Console.WriteLine();
             Console.WriteLine("Test Finished");
         }
     }
     class ExpensiveResource {
 
         //global instances created
         public static int InstanceCount;
 
         //resource id
         public int InstanceId { get; private set; }
 
         public ExpensiveResource() {
 
             InstanceId = Interlocked.Increment(ref InstanceCount);
             Console.WriteLine("Created Instance #: {0}",InstanceId);
         }
 
         public void ExpensiveProcess() {
             //simulate long process
             Random rnd = new Random(Guid.NewGuid().ToString().GetHashCode());
             int st = rnd.Next(500,1000);
             Thread.Sleep(st);
         }
     }
      */
     /// </example>
     /// <typeparam name="T">class</typeparam>
     public class ResourcePool<T> where T:class {
 
         protected readonly object _syncroot = new object();
         protected readonly BlockingCollection<T> _items;
         protected readonly Func<T> _factory;
         readonly int _timeout;
         volatile int _maxInstances;
         volatile int _created;
 
         /// <summary>Instances that were created</summary>
         public int InstancesCreated { get { return _created; } }
 
         /// <summary>Maximum instances that could be created</summary>
         public int MaxInstances { get { return _maxInstances; } }
 
         /// <summary>Gets the number of current objects available in the pool</summary>
         public int Count { get { return _items.Count; } }
 
         ///<summary>Gets the wait time if all resources are taken and no more can be created, default is -1 (infinity)</summary>
         public int Timeout { get { return _timeout; } }
 
         /// <summary>
         /// ctr
         /// </summary>
         /// <param name="maxInstances">Maximum number of instances that are to be created</param>
         /// <param name="factory">Factory function to create an instance of the specified Type </param>
         /// <param name="timeout">The wait time if all resources are taken and no more can be created, default is -1 (infinity)</param>
         public ResourcePool(int maxInstances,Func<T> factory,int timeout = -1) {
 
             if(factory == null)
                 throw new ArgumentNullException("factory");
 
             this._maxInstances = Math.Max(1,maxInstances);
             this._items = new BlockingCollection<T>(_maxInstances);
             this._factory = factory;
             this._timeout = timeout;
         }
 
         /// <summary>Increments the MaxInstances value</summary>
         public void IncrementMaxInstances(int count) {
             _maxInstances += count;
         }
 
         protected virtual void OnCreated(T instance) {
             return;
         }
         protected virtual bool CanReturn(T instance) {
             return true;
         }
 
         /// <summary>
         /// Returns an object back to the resource pool to be available the next time <see cref="Take"/> is called
         /// </summary>
         /// <param name="item">The object to be placed back into the pool</param>
         /// <returns>True if object is added back to the pool, otherwise false</returns>
         public virtual bool Return(T item) {
             if(item == null)
                 return false;
 
             bool added = false;
             if(CanReturn(item)) {
                 added = _items.TryAdd(item);
             }
 #if DEBUG
             Debug.WriteLine("Return-> hash: {0} - added: {1}",item.GetHashCode(),added);
 #endif
             return added;
         }
 
         /// <summary>
         /// Either takes an existing object from the pool, or it creates a new instance if the <see cref="InstancesCreated"/> have not exceed the <see cref="MaxInstances"/> value.
         /// </summary>
         /// <returns>An existing object from the pool or a new instnace</returns>
         public virtual T Take() {
 
 #if DEBUG
             int hash = -1;
             bool added = false;
 
 #endif
             bool created = false;
             T item = null;
 
             //take out the resource immediately
             if(_items.TryTake(out item,0))
                 return item;
 
             lock(_syncroot) {
 
                 //create resource if we can
                 if(_created < _maxInstances) {
 
                     item = _factory();
 
                     _created++;
                     _items.Add(item);
                     created = true;
                 }
             }
 
             if(created) {
                 OnCreated(item);
                 return item;
             }
 
             if(_created >= _maxInstances) {
 
                 //all resources are created, wait until there is one available
                 if(!_items.TryTake(out item,_timeout))
                     //we timed out
                     throw new TimeoutException();
             }
 
 #if DEBUG
             if(item != null)
                 hash = item.GetHashCode();
 
 #endif
             return item;
         }
     }
 }