1 files changed, 1423 insertions, 1136 deletions

diff --git a/ThirdParty/SmartThreadPool/SmartThreadPool.cs b/ThirdParty/SmartThreadPool/SmartThreadPool.cs
index 2c061d7..a4f4ce5 100644
--- a/ThirdParty/SmartThreadPool/SmartThreadPool.cs
+++ b/ThirdParty/SmartThreadPool/SmartThreadPool.cs
@@ -1,61 +1,106 @@
-// Ami Bar
-// amibar@gmail.com
-//
-// Smart thread pool in C#.
+#region Release History
+
+// Smart Thread Pool
 // 7 Aug 2004 - Initial release
+//
 // 14 Sep 2004 - Bug fixes 
+//
 // 15 Oct 2004 - Added new features
-//        - Work items return result.
-//        - Support waiting synchronization for multiple work items.
-//        - Work items can be cancelled.
-//        - Passage of the caller thread’s context to the thread in the pool.
-//        - Minimal usage of WIN32 handles.
-//        - Minor bug fixes.
+//              - Work items return result.
+//              - Support waiting synchronization for multiple work items.
+//              - Work items can be cancelled.
+//              - Passage of the caller thread’s context to the thread in the pool.
+//              - Minimal usage of WIN32 handles.
+//              - Minor bug fixes.
+//
 // 26 Dec 2004 - Changes:
-//        - Removed static constructors.
+//              - Removed static constructors.
 //      - Added finalizers.
-//        - Changed Exceptions so they are serializable.
-//        - Fixed the bug in one of the SmartThreadPool constructors.
-//        - Changed the SmartThreadPool.WaitAll() so it will support any number of waiters. 
+//              - Changed Exceptions so they are serializable.
+//              - Fixed the bug in one of the SmartThreadPool constructors.
+//              - Changed the SmartThreadPool.WaitAll() so it will support any number of waiters. 
 //        The SmartThreadPool.WaitAny() is still limited by the .NET Framework.
-//        - Added PostExecute with options on which cases to call it.
+//              - Added PostExecute with options on which cases to call it.
 //      - Added option to dispose of the state objects.
 //      - Added a WaitForIdle() method that waits until the work items queue is empty.
 //      - Added an STPStartInfo class for the initialization of the thread pool.
 //      - Changed exception handling so if a work item throws an exception it 
 //        is rethrown at GetResult(), rather then firing an UnhandledException event.
 //        Note that PostExecute exception are always ignored.
+//
 // 25 Mar 2005 - Changes:
-//        - Fixed lost of work items bug
+//              - Fixed lost of work items bug
+//
 // 3 Jul 2005: Changes.
 //      - Fixed bug where Enqueue() throws an exception because PopWaiter() returned null, hardly reconstructed. 
+//
 // 16 Aug 2005: Changes.
-//        - Fixed bug where the InUseThreads becomes negative when canceling work items. 
+//              - Fixed bug where the InUseThreads becomes negative when canceling work items. 
 //
 // 31 Jan 2006 - Changes:
-//        - Added work items priority
-//        - Removed support of chained delegates in callbacks and post executes (nobody really use this)
-//        - Added work items groups
-//        - Added work items groups idle event
-//        - Changed SmartThreadPool.WaitAll() behavior so when it gets empty array
-//          it returns true rather then throwing an exception.
-//        - Added option to start the STP and the WIG as suspended
-//        - Exception behavior changed, the real exception is returned by an 
-//          inner exception
-//        - Added option to keep the Http context of the caller thread. (Thanks to Steven T.)
-//        - Added performance counters
-//        - Added priority to the threads in the pool
+//              - Added work items priority
+//              - Removed support of chained delegates in callbacks and post executes (nobody really use this)
+//              - Added work items groups
+//              - Added work items groups idle event
+//              - Changed SmartThreadPool.WaitAll() behavior so when it gets empty array
+//                it returns true rather then throwing an exception.
+//              - Added option to start the STP and the WIG as suspended
+//              - Exception behavior changed, the real exception is returned by an 
+//                inner exception
+//              - Added option to keep the Http context of the caller thread. (Thanks to Steven T.)
+//              - Added performance counters
+//              - Added priority to the threads in the pool
 //
 // 13 Feb 2006 - Changes:
-//        - Added a call to the dispose of the Performance Counter so
-//          their won't be a Performance Counter leak.
-//        - Added exception catch in case the Performance Counters cannot 
-//          be created.
+//              - Added a call to the dispose of the Performance Counter so
+//                their won't be a Performance Counter leak.
+//              - Added exception catch in case the Performance Counters cannot 
+//                be created.
+//
+// 17 May 2008 - Changes:
+//      - Changed the dispose behavior and removed the Finalizers.
+//      - Enabled the change of the MaxThreads and MinThreads at run time.
+//      - Enabled the change of the Concurrency of a IWorkItemsGroup at run 
+//        time If the IWorkItemsGroup is a SmartThreadPool then the Concurrency 
+//        refers to the MaxThreads. 
+//      - Improved the cancel behavior.
+//      - Added events for thread creation and termination. 
+//      - Fixed the HttpContext context capture.
+//      - Changed internal collections so they use generic collections
+//      - Added IsIdle flag to the SmartThreadPool and IWorkItemsGroup
+//      - Added support for WinCE
+//      - Added support for Action<T> and Func<T>
+//
+// 07 April 2009 - Changes:
+//      - Added support for Silverlight and Mono
+//      - Added Join, Choice, and Pipe to SmartThreadPool.
+//      - Added local performance counters (for Mono, Silverlight, and WindowsCE)
+//      - Changed duration measures from DateTime.Now to Stopwatch.
+//      - Queues changed from System.Collections.Queue to System.Collections.Generic.LinkedList<T>.
+//
+// 21 December 2009 - Changes:
+//      - Added work item timeout (passive)
+//
+// 20 August 2012 - Changes:
+//      - Added set name to threads
+//      - Fixed the WorkItemsQueue.Dequeue. 
+//        Replaced while (!Monitor.TryEnter(this)); with lock(this) { ... }
+//      - Fixed SmartThreadPool.Pipe
+//      - Added IsBackground option to threads
+//      - Added ApartmentState to threads
+//      - Fixed thread creation when queuing many work items at the same time.
+//
+// 24 August 2012 - Changes:
+//      - Enabled cancel abort after cancel. See: http://smartthreadpool.codeplex.com/discussions/345937 by alecswan
+//      - Added option to set MaxStackSize of threads 
+
+#endregion
 
 using System;
 using System.Security;
 using System.Threading;
 using System.Collections;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 
@@ -63,1210 +108,1503 @@ using Amib.Threading.Internal;
 
 namespace Amib.Threading
 {
-    #region SmartThreadPool class
-    /// <summary>
-    /// Smart thread pool class.
-    /// </summary>
-    public class SmartThreadPool : IWorkItemsGroup, IDisposable
-    {
-        #region Default Constants
-
-        /// <summary>
-        /// Default minimum number of threads the thread pool contains. (0)
-        /// </summary>
-        public const int DefaultMinWorkerThreads = 0;
-
-        /// <summary>
-        /// Default maximum number of threads the thread pool contains. (25)
-        /// </summary>
-        public const int DefaultMaxWorkerThreads = 25;
-
-        /// <summary>
-        /// Default idle timeout in milliseconds. (One minute)
+        #region SmartThreadPool class
+        /// <summary>
+        /// Smart thread pool class.
+        /// </summary>
+        public partial class SmartThreadPool : WorkItemsGroupBase, IDisposable
+        {
+                #region Public Default Constants
+
+                /// <summary>
+                /// Default minimum number of threads the thread pool contains. (0)
+                /// </summary>
+                public const int DefaultMinWorkerThreads = 0;
+
+                /// <summary>
+                /// Default maximum number of threads the thread pool contains. (25)
+                /// </summary>
+                public const int DefaultMaxWorkerThreads = 25;
+
+                /// <summary>
+                /// Default idle timeout in milliseconds. (One minute)
+                /// </summary>
+                public const int DefaultIdleTimeout = 60*1000; // One minute
+
+                /// <summary>
+                /// Indicate to copy the security context of the caller and then use it in the call. (false)
+                /// </summary>
+                public const bool DefaultUseCallerCallContext = false; 
+
+                /// <summary>
+                /// Indicate to copy the HTTP context of the caller and then use it in the call. (false)
+                /// </summary>
+                public const bool DefaultUseCallerHttpContext = false;
+
+                /// <summary>
+                /// Indicate to dispose of the state objects if they support the IDispose interface. (false)
+                /// </summary>
+                public const bool DefaultDisposeOfStateObjects = false; 
+
+                /// <summary>
+        /// The default option to run the post execute (CallToPostExecute.Always)
+                /// </summary>
+                public const CallToPostExecute DefaultCallToPostExecute = CallToPostExecute.Always;
+
+                /// <summary>
+                /// The default post execute method to run. (None)
+                /// When null it means not to call it.
+                /// </summary>
+                public static readonly PostExecuteWorkItemCallback DefaultPostExecuteWorkItemCallback;
+
+                /// <summary>
+        /// The default work item priority (WorkItemPriority.Normal)
+                /// </summary>
+                public const WorkItemPriority DefaultWorkItemPriority = WorkItemPriority.Normal;
+
+                /// <summary>
+                /// The default is to work on work items as soon as they arrive
+                /// and not to wait for the start. (false)
+                /// </summary>
+                public const bool DefaultStartSuspended = false;
+
+                /// <summary>
+        /// The default name to use for the performance counters instance. (null)
+                /// </summary>
+                public static readonly string DefaultPerformanceCounterInstanceName;
+
+#if !(WINDOWS_PHONE)
+
+                /// <summary>
+        /// The default thread priority (ThreadPriority.Normal)
+                /// </summary>
+                public const ThreadPriority DefaultThreadPriority = ThreadPriority.Normal;
+#endif
+        /// <summary>
+        /// The default thread pool name. (SmartThreadPool)
         /// </summary>
-        public const int DefaultIdleTimeout = 60*1000; // One minute
+        public const string DefaultThreadPoolName = "SmartThreadPool";
 
         /// <summary>
-        /// Indicate to copy the security context of the caller and then use it in the call. (false)
+        /// The default Max Stack Size. (SmartThreadPool)
         /// </summary>
-        public const bool DefaultUseCallerCallContext = false; 
+        public static readonly int? DefaultMaxStackSize = null;
 
         /// <summary>
-        /// Indicate to copy the HTTP context of the caller and then use it in the call. (false)
+        /// The default fill state with params. (false)
+        /// It is relevant only to QueueWorkItem of Action&lt;...&gt;/Func&lt;...&gt;
         /// </summary>
-        public const bool DefaultUseCallerHttpContext = false;
+        public const bool DefaultFillStateWithArgs = false;
 
         /// <summary>
-        /// Indicate to dispose of the state objects if they support the IDispose interface. (false)
+        /// The default thread backgroundness. (true)
         /// </summary>
-        public const bool DefaultDisposeOfStateObjects = false; 
+        public const bool DefaultAreThreadsBackground = true;
 
+#if !(_SILVERLIGHT) && !(WINDOWS_PHONE)
         /// <summary>
-        /// The default option to run the post execute
+        /// The default apartment state of a thread in the thread pool. 
+        /// The default is ApartmentState.Unknown which means the STP will not 
+        /// set the apartment of the thread. It will use the .NET default.
         /// </summary>
-        public const CallToPostExecute DefaultCallToPostExecute = CallToPostExecute.Always;
+        public const ApartmentState DefaultApartmentState = ApartmentState.Unknown;
+#endif
 
-        /// <summary>
-        /// The default post execute method to run. 
-        /// When null it means not to call it.
-        /// </summary>
-        public static readonly PostExecuteWorkItemCallback DefaultPostExecuteWorkItemCallback = null;
+                #endregion
 
-        /// <summary>
-        /// The default work item priority
-        /// </summary>
-        public const WorkItemPriority DefaultWorkItemPriority = WorkItemPriority.Normal;
+        #region Member Variables
 
-        /// <summary>
-        /// The default is to work on work items as soon as they arrive
-        /// and not to wait for the start.
-        /// </summary>
-        public const bool DefaultStartSuspended = false;
+                /// <summary>
+                /// Dictionary of all the threads in the thread pool.
+                /// </summary>
+        private readonly SynchronizedDictionary<Thread, ThreadEntry> _workerThreads = new SynchronizedDictionary<Thread, ThreadEntry>();
 
-        /// <summary>
-        /// The default is not to use the performance counters
-        /// </summary>
-        public static readonly string DefaultPerformanceCounterInstanceName = null;
+                /// <summary>
+                /// Queue of work items.
+                /// </summary>
+                private readonly WorkItemsQueue _workItemsQueue = new WorkItemsQueue();
 
-        public static readonly int DefaultStackSize = 0;
+                /// <summary>
+                /// Count the work items handled.
+                /// Used by the performance counter.
+                /// </summary>
+                private int _workItemsProcessed;
 
-        /// <summary>
-        /// The default thread priority
-        /// </summary>
-        public const ThreadPriority DefaultThreadPriority = ThreadPriority.Normal;
+                /// <summary>
+                /// Number of threads that currently work (not idle).
+                /// </summary>
+                private int _inUseWorkerThreads;
 
         /// <summary>
-        /// The default thread pool name
+        /// Stores a copy of the original STPStartInfo.
+        /// It is used to change the MinThread and MaxThreads
         /// </summary>
-        public const string DefaultThreadPoolName = "SmartThreadPool";
+        private STPStartInfo _stpStartInfo;
 
-        #endregion
+                /// <summary>
+                /// Total number of work items that are stored in the work items queue 
+                /// plus the work items that the threads in the pool are working on.
+                /// </summary>
+                private int _currentWorkItemsCount;
 
-        #region Member Variables
+                /// <summary>
+                /// Signaled when the thread pool is idle, i.e. no thread is busy
+                /// and the work items queue is empty
+                /// </summary>
+                //private ManualResetEvent _isIdleWaitHandle = new ManualResetEvent(true);
+                private ManualResetEvent _isIdleWaitHandle = EventWaitHandleFactory.CreateManualResetEvent(true);
 
-        /// <summary>
-        /// Contains the name of this instance of SmartThreadPool.
-        /// Can be changed by the user.
-        /// </summary>
-        private string _name = DefaultThreadPoolName;
+                /// <summary>
+                /// An event to signal all the threads to quit immediately.
+                /// </summary>
+                //private ManualResetEvent _shuttingDownEvent = new ManualResetEvent(false);
+                private ManualResetEvent _shuttingDownEvent = EventWaitHandleFactory.CreateManualResetEvent(false);
 
         /// <summary>
-        /// Hashtable of all the threads in the thread pool.
+        /// A flag to indicate if the Smart Thread Pool is now suspended.
         /// </summary>
-        private Hashtable _workerThreads = Hashtable.Synchronized(new Hashtable());
+        private bool _isSuspended;
 
-        /// <summary>
-        /// Queue of work items.
-        /// </summary>
-        private WorkItemsQueue _workItemsQueue = new WorkItemsQueue();
+                /// <summary>
+                /// A flag to indicate the threads to quit.
+                /// </summary>
+                private bool _shutdown;
 
-        /// <summary>
-        /// Count the work items handled.
-        /// Used by the performance counter.
-        /// </summary>
-        private long _workItemsProcessed = 0;
+                /// <summary>
+                /// Counts the threads created in the pool.
+                /// It is used to name the threads.
+                /// </summary>
+                private int _threadCounter;
 
-        /// <summary>
-        /// Number of threads that currently work (not idle).
-        /// </summary>
-        private int _inUseWorkerThreads = 0;
+                /// <summary>
+                /// Indicate that the SmartThreadPool has been disposed
+                /// </summary>
+                private bool _isDisposed;
 
-        /// <summary>
-        /// Start information to use. 
-        /// It is simpler than providing many constructors.
-        /// </summary>
-        private STPStartInfo _stpStartInfo = new STPStartInfo();
+                /// <summary>
+                /// Holds all the WorkItemsGroup instaces that have at least one 
+                /// work item int the SmartThreadPool
+                /// This variable is used in case of Shutdown
+                /// </summary>
+        private readonly SynchronizedDictionary<IWorkItemsGroup, IWorkItemsGroup> _workItemsGroups = new SynchronizedDictionary<IWorkItemsGroup, IWorkItemsGroup>();
 
         /// <summary>
-        /// Total number of work items that are stored in the work items queue 
-        /// plus the work items that the threads in the pool are working on.
+        /// A common object for all the work items int the STP
+        /// so we can mark them to cancel in O(1)
         /// </summary>
-        private int _currentWorkItemsCount = 0;
+        private CanceledWorkItemsGroup _canceledSmartThreadPool = new CanceledWorkItemsGroup();
 
         /// <summary>
-        /// Signaled when the thread pool is idle, i.e. no thread is busy
-        /// and the work items queue is empty
+        /// Windows STP performance counters
         /// </summary>
-        private ManualResetEvent _isIdleWaitHandle = new ManualResetEvent(true);
+        private ISTPInstancePerformanceCounters _windowsPCs = NullSTPInstancePerformanceCounters.Instance;
 
         /// <summary>
-        /// An event to signal all the threads to quit immediately.
+        /// Local STP performance counters
         /// </summary>
-        private ManualResetEvent _shuttingDownEvent = new ManualResetEvent(false);
+        private ISTPInstancePerformanceCounters _localPCs = NullSTPInstancePerformanceCounters.Instance;
 
-        /// <summary>
-        /// A flag to indicate the threads to quit.
-        /// </summary>
-        private bool _shutdown = false;
 
-        /// <summary>
-        /// Counts the threads created in the pool.
-        /// It is used to name the threads.
-        /// </summary>
-        private int _threadCounter = 0;
+#if (WINDOWS_PHONE) 
+        private static readonly Dictionary<int, ThreadEntry> _threadEntries = new Dictionary<int, ThreadEntry>();
+#elif (_WINDOWS_CE)
+        private static LocalDataStoreSlot _threadEntrySlot = Thread.AllocateDataSlot();
+#else
+        [ThreadStatic]
+        private static ThreadEntry _threadEntry;
 
-        /// <summary>
-        /// Indicate that the SmartThreadPool has been disposed
-        /// </summary>
-        private bool _isDisposed = false;
+#endif
 
         /// <summary>
-        /// Event to send that the thread pool is idle
+        /// An event to call after a thread is created, but before 
+        /// it's first use.
         /// </summary>
-        private event EventHandler _stpIdle;
+        private event ThreadInitializationHandler _onThreadInitialization;
 
         /// <summary>
-        /// On idle event
+        /// An event to call when a thread is about to exit, after 
+        /// it is no longer belong to the pool.
         /// </summary>
-        //private event WorkItemsGroupIdleHandler _onIdle;
+        private event ThreadTerminationHandler _onThreadTermination;
 
-        /// <summary>
-        /// Holds all the WorkItemsGroup instaces that have at least one 
-        /// work item int the SmartThreadPool
-        /// This variable is used in case of Shutdown
-        /// </summary>
-        private Hashtable _workItemsGroups = Hashtable.Synchronized(new Hashtable());
+        #endregion
 
-        /// <summary>
-        /// A reference from each thread in the thread pool to its SmartThreadPool
-        /// object container.
-        /// With this variable a thread can know whatever it belongs to a 
-        /// SmartThreadPool.
-        /// </summary>
-        [ThreadStatic]
-        private static SmartThreadPool _smartThreadPool;
+        #region Per thread properties
 
         /// <summary>
         /// A reference to the current work item a thread from the thread pool 
         /// is executing.
         /// </summary>
-        [ThreadStatic]
-        private static WorkItem _currentWorkItem;
-
-        /// <summary>
-        /// STP performance counters
-        /// </summary>
-        private ISTPInstancePerformanceCounters _pcs = NullSTPInstancePerformanceCounters.Instance;
-
+        internal static ThreadEntry CurrentThreadEntry
+        {
+#if (WINDOWS_PHONE)
+            get
+            {
+                lock(_threadEntries)
+                {
+                    ThreadEntry threadEntry;
+                    if (_threadEntries.TryGetValue(Thread.CurrentThread.ManagedThreadId, out threadEntry))
+                    {
+                        return threadEntry;
+                    }
+                }
+                return null;
+            }
+            set
+            {
+                lock(_threadEntries)
+                {
+                    _threadEntries[Thread.CurrentThread.ManagedThreadId] = value;
+                }
+            }
+#elif (_WINDOWS_CE)
+            get
+            {
+                //Thread.CurrentThread.ManagedThreadId
+                return Thread.GetData(_threadEntrySlot) as ThreadEntry;
+            }
+            set
+            {
+                Thread.SetData(_threadEntrySlot, value);
+            }
+#else
+            get
+            {
+                return _threadEntry;
+            }
+            set
+            {
+                _threadEntry = value;
+            }
+#endif
+        }
         #endregion
 
         #region Construction and Finalization
 
         /// <summary>
-        /// Constructor
-        /// </summary>
-        public SmartThreadPool()
-        {
+                /// Constructor
+                /// </summary>
+                public SmartThreadPool()
+                {
+            _stpStartInfo = new STPStartInfo();
             Initialize();
-        }
-
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="idleTimeout">Idle timeout in milliseconds</param>
-        public SmartThreadPool(int idleTimeout)
-        {
-            _stpStartInfo.IdleTimeout = idleTimeout;
-            Initialize();
-        }
+                }
+
+                /// <summary>
+                /// Constructor
+                /// </summary>
+                /// <param name="idleTimeout">Idle timeout in milliseconds</param>
+                public SmartThreadPool(int idleTimeout)
+                {
+            _stpStartInfo = new STPStartInfo
+            {
+                IdleTimeout = idleTimeout,
+            };
+                        Initialize();
+                }
+
+                /// <summary>
+                /// Constructor
+                /// </summary>
+                /// <param name="idleTimeout">Idle timeout in milliseconds</param>
+                /// <param name="maxWorkerThreads">Upper limit of threads in the pool</param>
+                public SmartThreadPool(
+                        int idleTimeout,
+                        int maxWorkerThreads)
+                {
+            _stpStartInfo = new STPStartInfo
+            {
+                IdleTimeout = idleTimeout,
+                MaxWorkerThreads = maxWorkerThreads,
+            };
+                        Initialize();
+                }
+
+                /// <summary>
+                /// Constructor
+                /// </summary>
+                /// <param name="idleTimeout">Idle timeout in milliseconds</param>
+                /// <param name="maxWorkerThreads">Upper limit of threads in the pool</param>
+                /// <param name="minWorkerThreads">Lower limit of threads in the pool</param>
+                public SmartThreadPool(
+                        int idleTimeout,
+                        int maxWorkerThreads,
+                        int minWorkerThreads)
+                {
+            _stpStartInfo = new STPStartInfo
+            {
+                IdleTimeout = idleTimeout,
+                MaxWorkerThreads = maxWorkerThreads,
+                MinWorkerThreads = minWorkerThreads,
+            };
+                        Initialize();
+                }
 
         /// <summary>
         /// Constructor
         /// </summary>
-        /// <param name="idleTimeout">Idle timeout in milliseconds</param>
-        /// <param name="maxWorkerThreads">Upper limit of threads in the pool</param>
-        public SmartThreadPool(
-            int idleTimeout,
-            int maxWorkerThreads)
-        {
-            _stpStartInfo.IdleTimeout = idleTimeout;
-            _stpStartInfo.MaxWorkerThreads = maxWorkerThreads;
-            Initialize();
-        }
+        /// <param name="stpStartInfo">A SmartThreadPool configuration that overrides the default behavior</param>
+                public SmartThreadPool(STPStartInfo stpStartInfo)
+                {
+                        _stpStartInfo = new STPStartInfo(stpStartInfo);
+                        Initialize();
+                }
 
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="idleTimeout">Idle timeout in milliseconds</param>
-        /// <param name="maxWorkerThreads">Upper limit of threads in the pool</param>
-        /// <param name="minWorkerThreads">Lower limit of threads in the pool</param>
-        public SmartThreadPool(
-            int idleTimeout,
-            int maxWorkerThreads,
-            int minWorkerThreads)
-        {
-            _stpStartInfo.IdleTimeout = idleTimeout;
-            _stpStartInfo.MaxWorkerThreads = maxWorkerThreads;
-            _stpStartInfo.MinWorkerThreads = minWorkerThreads;
-            Initialize();
-        }
+                private void Initialize()
+                {
+            Name = _stpStartInfo.ThreadPoolName;
+                        ValidateSTPStartInfo();
 
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        public SmartThreadPool(STPStartInfo stpStartInfo)
-        {
-            _stpStartInfo = new STPStartInfo(stpStartInfo);
-            Initialize();
-        }
+            // _stpStartInfoRW stores a read/write copy of the STPStartInfo.
+            // Actually only MaxWorkerThreads and MinWorkerThreads are overwritten
 
-        private void Initialize()
-        {
-            Name = _stpStartInfo.ThreadPoolName;
-            ValidateSTPStartInfo();
+            _isSuspended = _stpStartInfo.StartSuspended;
 
+#if (_WINDOWS_CE) || (_SILVERLIGHT) || (_MONO) || (WINDOWS_PHONE)
+                        if (null != _stpStartInfo.PerformanceCounterInstanceName)
+                        {
+                throw new NotSupportedException("Performance counters are not implemented for Compact Framework/Silverlight/Mono, instead use StpStartInfo.EnableLocalPerformanceCounters");
+            }
+#else
             if (null != _stpStartInfo.PerformanceCounterInstanceName)
             {
                 try
                 {
-                    _pcs = new STPInstancePerformanceCounters(_stpStartInfo.PerformanceCounterInstanceName);
+                    _windowsPCs = new STPInstancePerformanceCounters(_stpStartInfo.PerformanceCounterInstanceName);
                 }
-                catch(Exception e)
+                catch (Exception e)
                 {
-                    Debug.WriteLine("Unable to create Performance Counters: " + e.ToString());
-                    _pcs = NullSTPInstancePerformanceCounters.Instance;
+                    Debug.WriteLine("Unable to create Performance Counters: " + e);
+                    _windowsPCs = NullSTPInstancePerformanceCounters.Instance;
                 }
             }
+#endif
 
-            StartOptimalNumberOfThreads();
-        }
-
-        private void StartOptimalNumberOfThreads()
-        {
-            int threadsCount = Math.Max(_workItemsQueue.Count, _stpStartInfo.MinWorkerThreads);
-            threadsCount = Math.Min(threadsCount, _stpStartInfo.MaxWorkerThreads);
-            StartThreads(threadsCount);
-        }
-
-        private void ValidateSTPStartInfo()
-        {
-            if (_stpStartInfo.MinWorkerThreads < 0)
-            {
-                throw new ArgumentOutOfRangeException(
-                    "MinWorkerThreads", "MinWorkerThreads cannot be negative");
-            }
-
-            if (_stpStartInfo.MaxWorkerThreads <= 0)
+            if (_stpStartInfo.EnableLocalPerformanceCounters)
             {
-                throw new ArgumentOutOfRangeException(
-                    "MaxWorkerThreads", "MaxWorkerThreads must be greater than zero");
+                _localPCs = new LocalSTPInstancePerformanceCounters();
             }
 
-            if (_stpStartInfo.MinWorkerThreads > _stpStartInfo.MaxWorkerThreads)
+                    // If the STP is not started suspended then start the threads.
+            if (!_isSuspended)
             {
-                throw new ArgumentOutOfRangeException(
-                    "MinWorkerThreads, maxWorkerThreads", 
-                    "MaxWorkerThreads must be greater or equal to MinWorkerThreads");
+                StartOptimalNumberOfThreads();
             }
-        }
+                }
 
-        private void ValidateCallback(Delegate callback)
-        {
-            if(callback.GetInvocationList().Length > 1)
+                private void StartOptimalNumberOfThreads()
+                {
+                        int threadsCount = Math.Max(_workItemsQueue.Count, _stpStartInfo.MinWorkerThreads);
+            threadsCount = Math.Min(threadsCount, _stpStartInfo.MaxWorkerThreads);
+            threadsCount -= _workerThreads.Count;
+            if (threadsCount > 0)
             {
-                throw new NotSupportedException("SmartThreadPool doesn't support delegates chains");
+                StartThreads(threadsCount);
             }
-        }
+                }
 
-        #endregion
+                private void ValidateSTPStartInfo()
+                {
+            if (_stpStartInfo.MinWorkerThreads < 0)
+                        {
+                                throw new ArgumentOutOfRangeException(
+                                        "MinWorkerThreads", "MinWorkerThreads cannot be negative");
+                        }
 
-        #region Thread Processing
+            if (_stpStartInfo.MaxWorkerThreads <= 0)
+                        {
+                                throw new ArgumentOutOfRangeException(
+                                        "MaxWorkerThreads", "MaxWorkerThreads must be greater than zero");
+                        }
 
-        /// <summary>
-        /// Waits on the queue for a work item, shutdown, or timeout.
-        /// </summary>
-        /// <returns>
-        /// Returns the WaitingCallback or null in case of timeout or shutdown.
-        /// </returns>
-        private WorkItem Dequeue()
-        {
-            WorkItem workItem = 
+            if (_stpStartInfo.MinWorkerThreads > _stpStartInfo.MaxWorkerThreads)
+                        {
+                                throw new ArgumentOutOfRangeException(
+                                        "MinWorkerThreads, maxWorkerThreads", 
+                                        "MaxWorkerThreads must be greater or equal to MinWorkerThreads");
+                        }
+                }
+
+                private static void ValidateCallback(Delegate callback)
+                {
+                        if(callback.GetInvocationList().Length > 1)
+                        {
+                                throw new NotSupportedException("SmartThreadPool doesn't support delegates chains");
+                        }
+                }
+
+                #endregion
+
+                #region Thread Processing
+
+                /// <summary>
+                /// Waits on the queue for a work item, shutdown, or timeout.
+                /// </summary>
+                /// <returns>
+                /// Returns the WaitingCallback or null in case of timeout or shutdown.
+                /// </returns>
+                private WorkItem Dequeue()
+                {
+                        WorkItem workItem =
                 _workItemsQueue.DequeueWorkItem(_stpStartInfo.IdleTimeout, _shuttingDownEvent);
 
-            return workItem;
-        }
-
-        /// <summary>
-        /// Put a new work item in the queue
-        /// </summary>
-        /// <param name="workItem">A work item to queue</param>
-        private void Enqueue(WorkItem workItem)
-        {
-            Enqueue(workItem, true);
-        }
-
-        /// <summary>
-        /// Put a new work item in the queue
-        /// </summary>
-        /// <param name="workItem">A work item to queue</param>
-        internal void Enqueue(WorkItem workItem, bool incrementWorkItems)
-        {
-            // Make sure the workItem is not null
-            Debug.Assert(null != workItem);
-
-            if (incrementWorkItems)
-            {
-                IncrementWorkItemsCount();
-            }
-
-            _workItemsQueue.EnqueueWorkItem(workItem);
-            workItem.WorkItemIsQueued();
-
-            // If all the threads are busy then try to create a new one
-            if ((InUseThreads + WaitingCallbacks) > _workerThreads.Count) 
-            {
-                StartThreads(1);
-            }
-        }
-
-        private void IncrementWorkItemsCount()
-        {
-            _pcs.SampleWorkItems(_workItemsQueue.Count, _workItemsProcessed);
-
-            int count = Interlocked.Increment(ref _currentWorkItemsCount);
-            //Trace.WriteLine("WorkItemsCount = " + _currentWorkItemsCount.ToString());
-            if (count == 1) 
-            {
-                //Trace.WriteLine("STP is NOT idle");
+                        return workItem;
+                }
+
+                /// <summary>
+                /// Put a new work item in the queue
+                /// </summary>
+                /// <param name="workItem">A work item to queue</param>
+                internal override void Enqueue(WorkItem workItem)
+                {
+                        // Make sure the workItem is not null
+                        Debug.Assert(null != workItem);
+
+                        IncrementWorkItemsCount();
+
+            workItem.CanceledSmartThreadPool = _canceledSmartThreadPool;
+                        _workItemsQueue.EnqueueWorkItem(workItem);
+                        workItem.WorkItemIsQueued();
+
+                        // If all the threads are busy then try to create a new one
+                        if (_currentWorkItemsCount > _workerThreads.Count) 
+                        {
+                                StartThreads(1);
+                        }
+                }
+
+                private void IncrementWorkItemsCount()
+                {
+                        _windowsPCs.SampleWorkItems(_workItemsQueue.Count, _workItemsProcessed);
+            _localPCs.SampleWorkItems(_workItemsQueue.Count, _workItemsProcessed);
+
+                        int count = Interlocked.Increment(ref _currentWorkItemsCount);
+                        //Trace.WriteLine("WorkItemsCount = " + _currentWorkItemsCount.ToString());
+                        if (count == 1) 
+                        {
+                IsIdle = false;
                 _isIdleWaitHandle.Reset();
-            }
-        }
-
-        private void DecrementWorkItemsCount()
-        {
-            ++_workItemsProcessed;
-
-            // The counter counts even if the work item was cancelled
-            _pcs.SampleWorkItems(_workItemsQueue.Count, _workItemsProcessed);
+                        }
+                }
 
+                private void DecrementWorkItemsCount()
+                {
             int count = Interlocked.Decrement(ref _currentWorkItemsCount);
             //Trace.WriteLine("WorkItemsCount = " + _currentWorkItemsCount.ToString());
-            if (count == 0) 
+            if (count == 0)
             {
-                //Trace.WriteLine("STP is idle");
+                IsIdle = true;
                 _isIdleWaitHandle.Set();
             }
-        }
 
-        internal void RegisterWorkItemsGroup(IWorkItemsGroup workItemsGroup)
-        {
-            _workItemsGroups[workItemsGroup] = workItemsGroup;
-        }
-
-        internal void UnregisterWorkItemsGroup(IWorkItemsGroup workItemsGroup)
-        {
-            if (_workItemsGroups.Contains(workItemsGroup))
-            {
-                _workItemsGroups.Remove(workItemsGroup);
-            }
-        }
+            Interlocked.Increment(ref _workItemsProcessed);
 
-        /// <summary>
-        /// Inform that the current thread is about to quit or quiting.
-        /// The same thread may call this method more than once.
-        /// </summary>
-        private void InformCompleted()
-        {
-            // There is no need to lock the two methods together 
-            // since only the current thread removes itself
-            // and the _workerThreads is a synchronized hashtable
-            if (_workerThreads.Contains(Thread.CurrentThread))
+            if (!_shutdown)
             {
-                _workerThreads.Remove(Thread.CurrentThread);
-                _pcs.SampleThreads(_workerThreads.Count, _inUseWorkerThreads);
+                            // The counter counts even if the work item was cancelled
+                            _windowsPCs.SampleWorkItems(_workItemsQueue.Count, _workItemsProcessed);
+                _localPCs.SampleWorkItems(_workItemsQueue.Count, _workItemsProcessed);
             }
-        }
 
-        /// <summary>
-        /// Starts new threads
-        /// </summary>
-        /// <param name="threadsCount">The number of threads to start</param>
-        private void StartThreads(int threadsCount)
-        {
-            if (_stpStartInfo.StartSuspended)
-            {
-                return;
-            }
+                }
+
+                internal void RegisterWorkItemsGroup(IWorkItemsGroup workItemsGroup)
+                {
+                        _workItemsGroups[workItemsGroup] = workItemsGroup;
+                }
+
+                internal void UnregisterWorkItemsGroup(IWorkItemsGroup workItemsGroup)
+                {
+                        if (_workItemsGroups.Contains(workItemsGroup))
+                        {
+                                _workItemsGroups.Remove(workItemsGroup);
+                        }
+                }
+
+                /// <summary>
+                /// Inform that the current thread is about to quit or quiting.
+                /// The same thread may call this method more than once.
+                /// </summary>
+                private void InformCompleted()
+                {
+                        // There is no need to lock the two methods together 
+                        // since only the current thread removes itself
+                        // and the _workerThreads is a synchronized dictionary
+                        if (_workerThreads.Contains(Thread.CurrentThread))
+                        {
+                                _workerThreads.Remove(Thread.CurrentThread);
+                                _windowsPCs.SampleThreads(_workerThreads.Count, _inUseWorkerThreads);
+                _localPCs.SampleThreads(_workerThreads.Count, _inUseWorkerThreads);
+                        }
+                }
+
+                /// <summary>
+                /// Starts new threads
+                /// </summary>
+                /// <param name="threadsCount">The number of threads to start</param>
+                private void StartThreads(int threadsCount)
+                {
+            if (_isSuspended)
+                        {
+                                return;
+                        }
+
+                        lock(_workerThreads.SyncRoot)
+                        {
+                                // Don't start threads on shut down
+                                if (_shutdown)
+                                {
+                                        return;
+                                }
+
+                                for(int i = 0; i < threadsCount; ++i)
+                                {
+                                        // Don't create more threads then the upper limit
+                    if (_workerThreads.Count >= _stpStartInfo.MaxWorkerThreads)
+                                        {
+                                                return;
+                                        }
 
-            lock(_workerThreads.SyncRoot)
-            {
-                // Don't start threads on shut down
-                if (_shutdown)
-                {
-                    return;
-                }
+                    // Create a new thread
 
-                for(int i = 0; i < threadsCount; ++i)
-                {
-                    // Don't create more threads then the upper limit
-                    if (_workerThreads.Count >= _stpStartInfo.MaxWorkerThreads)
+#if (_SILVERLIGHT) || (WINDOWS_PHONE)
+                                        Thread workerThread = new Thread(ProcessQueuedItems);
+#else
+                    Thread workerThread =
+                        _stpStartInfo.MaxStackSize.HasValue
+                        ? new Thread(ProcessQueuedItems, _stpStartInfo.MaxStackSize.Value)
+                        : new Thread(ProcessQueuedItems);
+#endif
+                                        // Configure the new thread and start it
+                                        workerThread.Name = "STP " + Name + " Thread #" + _threadCounter;
+                    workerThread.IsBackground = _stpStartInfo.AreThreadsBackground;
+
+#if !(_SILVERLIGHT) && !(_WINDOWS_CE) && !(WINDOWS_PHONE)
+                    if (_stpStartInfo.ApartmentState != ApartmentState.Unknown)
                     {
-                        return;
+                        workerThread.SetApartmentState(_stpStartInfo.ApartmentState);
                     }
+#endif
 
-                    // Create a new thread
-                    Thread workerThread;
-                    if (_stpStartInfo.StackSize > 0)
-                        workerThread = new Thread(ProcessQueuedItems, _stpStartInfo.StackSize);
-                    else
-                        workerThread = new Thread(ProcessQueuedItems);
-
-                    // Configure the new thread and start it
-                    workerThread.Name = "STP " + Name + " Thread #" + _threadCounter;
-                    workerThread.IsBackground = true;
+#if !(_SILVERLIGHT) && !(WINDOWS_PHONE)
                     workerThread.Priority = _stpStartInfo.ThreadPriority;
+#endif
                     workerThread.Start();
-                    ++_threadCounter;
-
-                    // Add the new thread to the hashtable and update its creation
-                    // time.
-                    _workerThreads[workerThread] = DateTime.Now;
-                    _pcs.SampleThreads(_workerThreads.Count, _inUseWorkerThreads);
-                }
-            }
-        }
-
-        /// <summary>
-        /// A worker thread method that processes work items from the work items queue.
-        /// </summary>
-        private void ProcessQueuedItems()
-        {
-            // Initialize the _smartThreadPool variable
-            _smartThreadPool = this;
-
-            try
-            {
-                bool bInUseWorkerThreadsWasIncremented = false;
-
-                // Process until shutdown.
-                while(!_shutdown)
-                {
-                    
-                    // Wait for a work item, shutdown, or timeout
-                    WorkItem workItem = Dequeue();
-
-                    // On timeout or shut down.
-                    if (null == workItem)
+                                        ++_threadCounter;
+
+                    // Add it to the dictionary and update its creation time.
+                    _workerThreads[workerThread] = new ThreadEntry(this);
+
+                                        _windowsPCs.SampleThreads(_workerThreads.Count, _inUseWorkerThreads);
+                    _localPCs.SampleThreads(_workerThreads.Count, _inUseWorkerThreads);
+                                }
+                        }
+                }
+
+                /// <summary>
+                /// A worker thread method that processes work items from the work items queue.
+                /// </summary>
+                private void ProcessQueuedItems()
+                {
+            // Keep the entry of the dictionary as thread's variable to avoid the synchronization locks
+            // of the dictionary.
+            CurrentThreadEntry = _workerThreads[Thread.CurrentThread];
+
+            FireOnThreadInitialization();
+
+                        try
+                        {
+                                bool bInUseWorkerThreadsWasIncremented = false;
+
+                                // Process until shutdown.
+                                while(!_shutdown)
+                                {
+                                        // Update the last time this thread was seen alive.
+                                        // It's good for debugging.
+                    CurrentThreadEntry.IAmAlive();
+
+                    // The following block handles the when the MaxWorkerThreads has been
+                    // incremented by the user at run-time.
+                    // Double lock for quit.
+                    if (_workerThreads.Count > _stpStartInfo.MaxWorkerThreads)
                     {
-                        // Double lock for quit.
-                        if (_workerThreads.Count > _stpStartInfo.MinWorkerThreads)
+                        lock (_workerThreads.SyncRoot)
                         {
-                            lock(_workerThreads.SyncRoot)
+                            if (_workerThreads.Count > _stpStartInfo.MaxWorkerThreads)
                             {
-                                // Update the last time this thread was seen alive.
-                                // It's good for debugging.
-                                _workerThreads[Thread.CurrentThread] = DateTime.Now;
-
-                                if (_workerThreads.Count > _stpStartInfo.MinWorkerThreads)
-                                {
-                                    // Inform that the thread is quiting and then quit.
-                                    // This method must be called within this lock or else
-                                    // more threads will quit and the thread pool will go
-                                    // below the lower limit.
-                                    InformCompleted();
-                                    break;
-                                }
+                                // Inform that the thread is quiting and then quit.
+                                // This method must be called within this lock or else
+                                // more threads will quit and the thread pool will go
+                                // below the lower limit.
+                                InformCompleted();
+                                break;
                             }
                         }
                     }
 
-                    // If we didn't quit then skip to the next iteration.
-                    if (null == workItem)
-                    {
-                        continue;
-                    }
-
-                    try 
-                    {
-                        // Initialize the value to false
-                        bInUseWorkerThreadsWasIncremented = false;
-
-                        // Change the state of the work item to 'in progress' if possible.
-                        // We do it here so if the work item has been canceled we won't 
-                        // increment the _inUseWorkerThreads.
-                        // The cancel mechanism doesn't delete items from the queue,  
-                        // it marks the work item as canceled, and when the work item
-                        // is dequeued, we just skip it.
-                        // If the post execute of work item is set to always or to
-                        // call when the work item is canceled then the StartingWorkItem()
-                        // will return true, so the post execute can run.
-                        if (!workItem.StartingWorkItem())
-                        {
-                            continue;
-                        }
+                                        // Wait for a work item, shutdown, or timeout
+                                        WorkItem workItem = Dequeue();
 
-                        // Execute the callback.  Make sure to accurately
-                        // record how many callbacks are currently executing.
-                        int inUseWorkerThreads = Interlocked.Increment(ref _inUseWorkerThreads);
-                        _pcs.SampleThreads(_workerThreads.Count, inUseWorkerThreads);
+                                        // Update the last time this thread was seen alive.
+                                        // It's good for debugging.
+                    CurrentThreadEntry.IAmAlive();
 
-                        // Mark that the _inUseWorkerThreads incremented, so in the finally{}
-                        // statement we will decrement it correctly.
-                        bInUseWorkerThreadsWasIncremented = true;
-
-                        // Set the _currentWorkItem to the current work item
-                        _currentWorkItem = workItem;
-
-                        lock(workItem)
-                        {
-                            workItem.currentThread = Thread.CurrentThread;
-                        }
-
-                        ExecuteWorkItem(workItem);
-
-                        lock(workItem)
-                        {
-                            workItem.currentThread = null;
-                        }
-
-                    }
-                    catch(ThreadAbortException ex)
-                    {
-                        lock(workItem)
-                        {
-                            workItem.currentThread = null;
-                        }
-                        ex.GetHashCode();
-                        Thread.ResetAbort();
-                    }
-                    catch(Exception ex)
-                    {
+                                        // On timeout or shut down.
+                                        if (null == workItem)
+                                        {
+                                                // Double lock for quit.
+                        if (_workerThreads.Count > _stpStartInfo.MinWorkerThreads)
+                                                {
+                                                        lock(_workerThreads.SyncRoot)
+                                                        {
+                                if (_workerThreads.Count > _stpStartInfo.MinWorkerThreads)
+                                                                {
+                                                                        // Inform that the thread is quiting and then quit.
+                                                                        // This method must be called within this lock or else
+                                                                        // more threads will quit and the thread pool will go
+                                                                        // below the lower limit.
+                                                                        InformCompleted();
+                                                                        break;
+                                                                }
+                                                        }
+                                                }
+                                        }
+
+                                        // If we didn't quit then skip to the next iteration.
+                                        if (null == workItem)
+                                        {
+                                                continue;
+                                        }
+
+                                        try 
+                                        {
+                                                // Initialize the value to false
+                                                bInUseWorkerThreadsWasIncremented = false;
+
+                        // Set the Current Work Item of the thread.
+                        // Store the Current Work Item  before the workItem.StartingWorkItem() is called, 
+                        // so WorkItem.Cancel can work when the work item is between InQueue and InProgress 
+                        // states.
+                        // If the work item has been cancelled BEFORE the workItem.StartingWorkItem() 
+                        // (work item is in InQueue state) then workItem.StartingWorkItem() will return false.
+                        // If the work item has been cancelled AFTER the workItem.StartingWorkItem() then
+                        // (work item is in InProgress state) then the thread will be aborted
+                        CurrentThreadEntry.CurrentWorkItem = workItem;
+
+                                                // Change the state of the work item to 'in progress' if possible.
+                                                // We do it here so if the work item has been canceled we won't 
+                                                // increment the _inUseWorkerThreads.
+                                                // The cancel mechanism doesn't delete items from the queue,  
+                                                // it marks the work item as canceled, and when the work item
+                                                // is dequeued, we just skip it.
+                                                // If the post execute of work item is set to always or to
+                                                // call when the work item is canceled then the StartingWorkItem()
+                                                // will return true, so the post execute can run.
+                                                if (!workItem.StartingWorkItem())
+                                                {
+                                                        continue;
+                                                }
+
+                                                // Execute the callback.  Make sure to accurately
+                                                // record how many callbacks are currently executing.
+                                                int inUseWorkerThreads = Interlocked.Increment(ref _inUseWorkerThreads);
+                                                _windowsPCs.SampleThreads(_workerThreads.Count, inUseWorkerThreads);
+                        _localPCs.SampleThreads(_workerThreads.Count, inUseWorkerThreads);
+
+                                                // Mark that the _inUseWorkerThreads incremented, so in the finally{}
+                                                // statement we will decrement it correctly.
+                                                bInUseWorkerThreadsWasIncremented = true;
+
+                        workItem.FireWorkItemStarted();
+
+                                                ExecuteWorkItem(workItem);
+                                        }
+                                        catch(Exception ex)
+                                        {
                         ex.GetHashCode();
-                        // Do nothing
-                    }
-                    finally
-                    {
-                        lock(workItem)
-                        {
-                            workItem.currentThread = null;
-                        }
-
-                        if (null != workItem)
-                        {
-                            workItem.DisposeOfState();
-                        }
-
-                        // Set the _currentWorkItem to null, since we 
-                        // no longer run user's code.
-                        _currentWorkItem = null;
-
-                        // Decrement the _inUseWorkerThreads only if we had 
-                        // incremented it. Note the cancelled work items don't
-                        // increment _inUseWorkerThreads.
-                        if (bInUseWorkerThreadsWasIncremented)
-                        {
-                            int inUseWorkerThreads = Interlocked.Decrement(ref _inUseWorkerThreads);
-                            _pcs.SampleThreads(_workerThreads.Count, inUseWorkerThreads);
-                        }
-
-                        // Notify that the work item has been completed.
-                        // WorkItemsGroup may enqueue their next work item.
-                        workItem.FireWorkItemCompleted();
-
-                        // Decrement the number of work items here so the idle 
-                        // ManualResetEvent won't fluctuate.
-                        DecrementWorkItemsCount();
-                    }
-                }
-            } 
-            catch(ThreadAbortException tae)
-            {
+                                                // Do nothing
+                                        }
+                                        finally
+                                        {
+                                                workItem.DisposeOfState();
+
+                                                // Set the CurrentWorkItem to null, since we 
+                                                // no longer run user's code.
+                        CurrentThreadEntry.CurrentWorkItem = null;
+
+                                                // Decrement the _inUseWorkerThreads only if we had 
+                                                // incremented it. Note the cancelled work items don't
+                                                // increment _inUseWorkerThreads.
+                                                if (bInUseWorkerThreadsWasIncremented)
+                                                {
+                                                        int inUseWorkerThreads = Interlocked.Decrement(ref _inUseWorkerThreads);
+                                                        _windowsPCs.SampleThreads(_workerThreads.Count, inUseWorkerThreads);
+                            _localPCs.SampleThreads(_workerThreads.Count, inUseWorkerThreads);
+                                                }
+
+                                                // Notify that the work item has been completed.
+                                                // WorkItemsGroup may enqueue their next work item.
+                                                workItem.FireWorkItemCompleted();
+
+                                                // Decrement the number of work items here so the idle 
+                                                // ManualResetEvent won't fluctuate.
+                                                DecrementWorkItemsCount();
+                                        }
+                                }
+                        } 
+                        catch(ThreadAbortException tae)
+                        {
                 tae.GetHashCode();
                 // Handle the abort exception gracfully.
-                Thread.ResetAbort();
-            }
-            catch(Exception e)
-            {
-                Debug.Assert(null != e);
-            }
-            finally
-            {
-                InformCompleted();
-            }
-        }
-
-        private void ExecuteWorkItem(WorkItem workItem)
-        {
-            _pcs.SampleWorkItemsWaitTime(workItem.WaitingTime);
-            try
-            {
-                workItem.Execute();
-            }
-            catch
-            {
-                throw;
+#if !(_WINDOWS_CE) && !(_SILVERLIGHT) && !(WINDOWS_PHONE)
+                                Thread.ResetAbort();
+#endif
             }
-            finally
+                        catch(Exception e)
+                        {
+                                Debug.Assert(null != e);
+                        }
+                        finally
+                        {
+                                InformCompleted();
+                FireOnThreadTermination();
+                        }
+                }
+
+                private void ExecuteWorkItem(WorkItem workItem)
+                {
+                        _windowsPCs.SampleWorkItemsWaitTime(workItem.WaitingTime);
+            _localPCs.SampleWorkItemsWaitTime(workItem.WaitingTime);
+                        try
+                        {
+                                workItem.Execute();
+                        }
+                        finally
+                        {
+                                _windowsPCs.SampleWorkItemsProcessTime(workItem.ProcessTime);
+                _localPCs.SampleWorkItemsProcessTime(workItem.ProcessTime);
+                        }
+                }
+
+
+                #endregion
+
+                #region Public Methods
+
+                private void ValidateWaitForIdle()
+                {
+            if (null != CurrentThreadEntry && CurrentThreadEntry.AssociatedSmartThreadPool == this)
+                        {
+                                throw new NotSupportedException(
+                                        "WaitForIdle cannot be called from a thread on its SmartThreadPool, it causes a deadlock");
+                        }
+                }
+
+                internal static void ValidateWorkItemsGroupWaitForIdle(IWorkItemsGroup workItemsGroup)
+                {
+            if (null == CurrentThreadEntry)
             {
-                _pcs.SampleWorkItemsProcessTime(workItem.ProcessTime);
+                return;
             }
-        }
-
-
-        #endregion
 
-        #region Public Methods
-
-        /// <summary>
-        /// Queue a work item
+            WorkItem workItem = CurrentThreadEntry.CurrentWorkItem;
+            ValidateWorkItemsGroupWaitForIdleImpl(workItemsGroup, workItem);
+                        if ((null != workItemsGroup) &&
+                (null != workItem) &&
+                CurrentThreadEntry.CurrentWorkItem.WasQueuedBy(workItemsGroup))
+                        {
+                                throw new NotSupportedException("WaitForIdle cannot be called from a thread on its SmartThreadPool, it causes a deadlock");
+                        }
+                }
+
+                [MethodImpl(MethodImplOptions.NoInlining)]
+                private static void ValidateWorkItemsGroupWaitForIdleImpl(IWorkItemsGroup workItemsGroup, WorkItem workItem)
+                {
+                        if ((null != workItemsGroup) && 
+                                (null != workItem) &&
+                                workItem.WasQueuedBy(workItemsGroup))
+                        {
+                                throw new NotSupportedException("WaitForIdle cannot be called from a thread on its SmartThreadPool, it causes a deadlock");
+                        }
+                }
+
+                /// <summary>
+                /// Force the SmartThreadPool to shutdown
+                /// </summary>
+                public void Shutdown()
+                {
+                        Shutdown(true, 0);
+                }
+
+        /// <summary>
+        /// Force the SmartThreadPool to shutdown with timeout
         /// </summary>
-        /// <param name="callback">A callback to execute</param>
-        /// <returns>Returns a work item result</returns>
-        public IWorkItemResult QueueWorkItem(WorkItemCallback callback)
-        {
-            ValidateNotDisposed();
-            ValidateCallback(callback);
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, callback);
-            Enqueue(workItem);
-            return workItem.GetWorkItemResult();
-        }
+        public void Shutdown(bool forceAbort, TimeSpan timeout)
+                {
+                        Shutdown(forceAbort, (int)timeout.TotalMilliseconds);
+                }
+
+                /// <summary>
+                /// Empties the queue of work items and abort the threads in the pool.
+                /// </summary>
+                public void Shutdown(bool forceAbort, int millisecondsTimeout)
+                {
+                        ValidateNotDisposed();
+
+                        ISTPInstancePerformanceCounters pcs = _windowsPCs;
+
+                        if (NullSTPInstancePerformanceCounters.Instance != _windowsPCs)
+                        {
+                                // Set the _pcs to "null" to stop updating the performance
+                                // counters
+                                _windowsPCs = NullSTPInstancePerformanceCounters.Instance;
+
+                pcs.Dispose();
+                        }
+
+                        Thread [] threads;
+                        lock(_workerThreads.SyncRoot)
+                        {
+                                // Shutdown the work items queue
+                                _workItemsQueue.Dispose();
+
+                                // Signal the threads to exit
+                                _shutdown = true;
+                                _shuttingDownEvent.Set();
+
+                                // Make a copy of the threads' references in the pool
+                                threads = new Thread [_workerThreads.Count];
+                                _workerThreads.Keys.CopyTo(threads, 0);
+                        }
+
+                        int millisecondsLeft = millisecondsTimeout;
+            Stopwatch stopwatch = Stopwatch.StartNew();
+            //DateTime start = DateTime.UtcNow;
+                        bool waitInfinitely = (Timeout.Infinite == millisecondsTimeout);
+                        bool timeout = false;
+
+                        // Each iteration we update the time left for the timeout.
+                        foreach(Thread thread in threads)
+                        {
+                                // Join don't work with negative numbers
+                                if (!waitInfinitely && (millisecondsLeft < 0))
+                                {
+                                        timeout = true;
+                                        break;
+                                }
+
+                                // Wait for the thread to terminate
+                                bool success = thread.Join(millisecondsLeft);
+                                if(!success)
+                                {
+                                        timeout = true;
+                                        break;
+                                }
+
+                                if(!waitInfinitely)
+                                {
+                                        // Update the time left to wait
+                    //TimeSpan ts = DateTime.UtcNow - start;
+                    millisecondsLeft = millisecondsTimeout - (int)stopwatch.ElapsedMilliseconds;
+                                }
+                        }
+
+                        if (timeout && forceAbort)
+                        {
+                                // Abort the threads in the pool
+                                foreach(Thread thread in threads)
+                                {
+                    
+                                        if ((thread != null)
+#if !(_WINDOWS_CE)
+                        && thread.IsAlive
+#endif                        
+                        )
+                                        {
+                                                try 
+                                                {
+                            thread.Abort(); // Shutdown
+                                                }
+                                                catch(SecurityException e)
+                                                {
+                            e.GetHashCode();
+                                                }
+                                                catch(ThreadStateException ex)
+                                                {
+                            ex.GetHashCode();
+                                                        // In case the thread has been terminated 
+                                                        // after the check if it is alive.
+                                                }
+                                        }
+                                }
+                        }
+                }
+
+                /// <summary>
+                /// Wait for all work items to complete
+                /// </summary>
+        /// <param name="waitableResults">Array of work item result objects</param>
+                /// <returns>
+                /// true when every work item in workItemResults has completed; otherwise false.
+                /// </returns>
+                public static bool WaitAll(
+                        IWaitableResult [] waitableResults)
+                {
+            return WaitAll(waitableResults, Timeout.Infinite, true);
+                }
+
+                /// <summary>
+                /// Wait for all work items to complete
+                /// </summary>
+        /// <param name="waitableResults">Array of work item result objects</param>
+                /// <param name="timeout">The number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. </param>
+                /// <param name="exitContext">
+                /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
+                /// </param>
+                /// <returns>
+                /// true when every work item in workItemResults has completed; otherwise false.
+                /// </returns>
+                public static bool WaitAll(
+                        IWaitableResult [] waitableResults,
+                        TimeSpan timeout,
+                        bool exitContext)
+                {
+            return WaitAll(waitableResults, (int)timeout.TotalMilliseconds, exitContext);
+                }
+
+                /// <summary>
+                /// Wait for all work items to complete
+                /// </summary>
+        /// <param name="waitableResults">Array of work item result objects</param>
+                /// <param name="timeout">The number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. </param>
+                /// <param name="exitContext">
+                /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
+                /// </param>
+                /// <param name="cancelWaitHandle">A cancel wait handle to interrupt the wait if needed</param>
+                /// <returns>
+                /// true when every work item in workItemResults has completed; otherwise false.
+                /// </returns>
+                public static bool WaitAll(
+            IWaitableResult[] waitableResults,  
+                        TimeSpan timeout,
+                        bool exitContext,
+                        WaitHandle cancelWaitHandle)
+                {
+            return WaitAll(waitableResults, (int)timeout.TotalMilliseconds, exitContext, cancelWaitHandle);
+                }
+
+                /// <summary>
+                /// Wait for all work items to complete
+                /// </summary>
+        /// <param name="waitableResults">Array of work item result objects</param>
+                /// <param name="millisecondsTimeout">The number of milliseconds to wait, or Timeout.Infinite (-1) to wait indefinitely.</param>
+                /// <param name="exitContext">
+                /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
+                /// </param>
+                /// <returns>
+                /// true when every work item in workItemResults has completed; otherwise false.
+                /// </returns>
+                public static bool WaitAll(
+                        IWaitableResult [] waitableResults,  
+                        int millisecondsTimeout,
+                        bool exitContext)
+                {
+            return WorkItem.WaitAll(waitableResults, millisecondsTimeout, exitContext, null);
+                }
+
+                /// <summary>
+                /// Wait for all work items to complete
+                /// </summary>
+        /// <param name="waitableResults">Array of work item result objects</param>
+                /// <param name="millisecondsTimeout">The number of milliseconds to wait, or Timeout.Infinite (-1) to wait indefinitely.</param>
+                /// <param name="exitContext">
+                /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
+                /// </param>
+                /// <param name="cancelWaitHandle">A cancel wait handle to interrupt the wait if needed</param>
+                /// <returns>
+                /// true when every work item in workItemResults has completed; otherwise false.
+                /// </returns>
+                public static bool WaitAll(
+            IWaitableResult[] waitableResults,  
+                        int millisecondsTimeout,
+                        bool exitContext,
+                        WaitHandle cancelWaitHandle)
+                {
+            return WorkItem.WaitAll(waitableResults, millisecondsTimeout, exitContext, cancelWaitHandle);
+                }
+
+
+                /// <summary>
+                /// Waits for any of the work items in the specified array to complete, cancel, or timeout
+                /// </summary>
+        /// <param name="waitableResults">Array of work item result objects</param>
+                /// <returns>
+                /// The array index of the work item result that satisfied the wait, or WaitTimeout if any of the work items has been canceled.
+                /// </returns>
+                public static int WaitAny(
+                        IWaitableResult [] waitableResults)
+                {
+            return WaitAny(waitableResults, Timeout.Infinite, true);
+                }
+
+                /// <summary>
+                /// Waits for any of the work items in the specified array to complete, cancel, or timeout
+                /// </summary>
+        /// <param name="waitableResults">Array of work item result objects</param>
+                /// <param name="timeout">The number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. </param>
+                /// <param name="exitContext">
+                /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
+                /// </param>
+                /// <returns>
+                /// The array index of the work item result that satisfied the wait, or WaitTimeout if no work item result satisfied the wait and a time interval equivalent to millisecondsTimeout has passed or the work item has been canceled.
+                /// </returns>
+                public static int WaitAny(
+            IWaitableResult[] waitableResults,
+                        TimeSpan timeout,
+                        bool exitContext)
+                {
+            return WaitAny(waitableResults, (int)timeout.TotalMilliseconds, exitContext);
+                }
+
+                /// <summary>
+                /// Waits for any of the work items in the specified array to complete, cancel, or timeout
+                /// </summary>
+        /// <param name="waitableResults">Array of work item result objects</param>
+                /// <param name="timeout">The number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. </param>
+                /// <param name="exitContext">
+                /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
+                /// </param>
+                /// <param name="cancelWaitHandle">A cancel wait handle to interrupt the wait if needed</param>
+                /// <returns>
+                /// The array index of the work item result that satisfied the wait, or WaitTimeout if no work item result satisfied the wait and a time interval equivalent to millisecondsTimeout has passed or the work item has been canceled.
+                /// </returns>
+                public static int WaitAny(
+                        IWaitableResult [] waitableResults,
+                        TimeSpan timeout,
+                        bool exitContext,
+                        WaitHandle cancelWaitHandle)
+                {
+            return WaitAny(waitableResults, (int)timeout.TotalMilliseconds, exitContext, cancelWaitHandle);
+                }
+
+                /// <summary>
+                /// Waits for any of the work items in the specified array to complete, cancel, or timeout
+                /// </summary>
+        /// <param name="waitableResults">Array of work item result objects</param>
+                /// <param name="millisecondsTimeout">The number of milliseconds to wait, or Timeout.Infinite (-1) to wait indefinitely.</param>
+                /// <param name="exitContext">
+                /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
+                /// </param>
+                /// <returns>
+                /// The array index of the work item result that satisfied the wait, or WaitTimeout if no work item result satisfied the wait and a time interval equivalent to millisecondsTimeout has passed or the work item has been canceled.
+                /// </returns>
+                public static int WaitAny(
+                        IWaitableResult [] waitableResults,  
+                        int millisecondsTimeout,
+                        bool exitContext)
+                {
+            return WorkItem.WaitAny(waitableResults, millisecondsTimeout, exitContext, null);
+                }
+
+                /// <summary>
+                /// Waits for any of the work items in the specified array to complete, cancel, or timeout
+                /// </summary>
+        /// <param name="waitableResults">Array of work item result objects</param>
+                /// <param name="millisecondsTimeout">The number of milliseconds to wait, or Timeout.Infinite (-1) to wait indefinitely.</param>
+                /// <param name="exitContext">
+                /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
+                /// </param>
+                /// <param name="cancelWaitHandle">A cancel wait handle to interrupt the wait if needed</param>
+                /// <returns>
+                /// The array index of the work item result that satisfied the wait, or WaitTimeout if no work item result satisfied the wait and a time interval equivalent to millisecondsTimeout has passed or the work item has been canceled.
+                /// </returns>
+                public static int WaitAny(
+                        IWaitableResult [] waitableResults,  
+                        int millisecondsTimeout,
+                        bool exitContext,
+                        WaitHandle cancelWaitHandle)
+                {
+            return WorkItem.WaitAny(waitableResults, millisecondsTimeout, exitContext, cancelWaitHandle);
+                }
+
+        /// <summary>
+        /// Creates a new WorkItemsGroup.
+        /// </summary>
+        /// <param name="concurrency">The number of work items that can be run concurrently</param>
+        /// <returns>A reference to the WorkItemsGroup</returns>
+                public IWorkItemsGroup CreateWorkItemsGroup(int concurrency)
+                {
+            IWorkItemsGroup workItemsGroup = new WorkItemsGroup(this, concurrency, _stpStartInfo);
+                        return workItemsGroup;
+                }
 
         /// <summary>
-        /// Queue a work item
+        /// Creates a new WorkItemsGroup.
         /// </summary>
-        /// <param name="callback">A callback to execute</param>
-        /// <param name="workItemPriority">The priority of the work item</param>
-        /// <returns>Returns a work item result</returns>
-        public IWorkItemResult QueueWorkItem(WorkItemCallback callback, WorkItemPriority workItemPriority)
-        {
-            ValidateNotDisposed();
-            ValidateCallback(callback);
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, callback, workItemPriority);
-            Enqueue(workItem);
-            return workItem.GetWorkItemResult();
-        }
+        /// <param name="concurrency">The number of work items that can be run concurrently</param>
+        /// <param name="wigStartInfo">A WorkItemsGroup configuration that overrides the default behavior</param>
+        /// <returns>A reference to the WorkItemsGroup</returns>
+                public IWorkItemsGroup CreateWorkItemsGroup(int concurrency, WIGStartInfo wigStartInfo)
+                {
+                        IWorkItemsGroup workItemsGroup = new WorkItemsGroup(this, concurrency, wigStartInfo);
+                        return workItemsGroup;
+                }
 
-        /// <summary>
-        /// Queue a work item
-        /// </summary>
-        /// <param name="workItemInfo">Work item info</param>
-        /// <param name="callback">A callback to execute</param>
-        /// <returns>Returns a work item result</returns>
-        public IWorkItemResult QueueWorkItem(WorkItemInfo workItemInfo, WorkItemCallback callback)
-        {
-            ValidateNotDisposed();
-            ValidateCallback(callback);
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, workItemInfo, callback);
-            Enqueue(workItem);
-            return workItem.GetWorkItemResult();
-        }
+        #region Fire Thread's Events
 
-        /// <summary>
-        /// Queue a work item
-        /// </summary>
-        /// <param name="callback">A callback to execute</param>
-        /// <param name="state">
-        /// The context object of the work item. Used for passing arguments to the work item. 
-        /// </param>
-        /// <returns>Returns a work item result</returns>
-        public IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state)
+        private void FireOnThreadInitialization()
         {
-            ValidateNotDisposed();
-            ValidateCallback(callback);
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, callback, state);
-            Enqueue(workItem);
-            return workItem.GetWorkItemResult();
+            if (null != _onThreadInitialization)
+            {
+                foreach (ThreadInitializationHandler tih in _onThreadInitialization.GetInvocationList())
+                {
+                    try
+                    {
+                        tih();
+                    }
+                    catch (Exception e)
+                    {
+                        e.GetHashCode();
+                        Debug.Assert(false);
+                        throw;
+                    }
+                }
+            }
         }
 
-        /// <summary>
-        /// Queue a work item
-        /// </summary>
-        /// <param name="callback">A callback to execute</param>
-        /// <param name="state">
-        /// The context object of the work item. Used for passing arguments to the work item. 
-        /// </param>
-        /// <param name="workItemPriority">The work item priority</param>
-        /// <returns>Returns a work item result</returns>
-        public IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state, WorkItemPriority workItemPriority)
+        private void FireOnThreadTermination()
         {
-            ValidateNotDisposed();
-            ValidateCallback(callback);
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, callback, state, workItemPriority);
-            Enqueue(workItem);
-            return workItem.GetWorkItemResult();
+            if (null != _onThreadTermination)
+            {
+                foreach (ThreadTerminationHandler tth in _onThreadTermination.GetInvocationList())
+                {
+                    try
+                    {
+                        tth();
+                    }
+                    catch (Exception e)
+                    {
+                        e.GetHashCode();
+                        Debug.Assert(false);
+                        throw;
+                    }
+                }
+            }
         }
 
-        /// <summary>
-        /// Queue a work item
-        /// </summary>
-        /// <param name="workItemInfo">Work item information</param>
-        /// <param name="callback">A callback to execute</param>
-        /// <param name="state">
-        /// The context object of the work item. Used for passing arguments to the work item. 
-        /// </param>
-        /// <returns>Returns a work item result</returns>
-        public IWorkItemResult QueueWorkItem(WorkItemInfo workItemInfo, WorkItemCallback callback, object state)
-        {
-            ValidateNotDisposed();
-            ValidateCallback(callback);
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, workItemInfo, callback, state);
-            Enqueue(workItem);
-            return workItem.GetWorkItemResult();
-        }
+        #endregion
 
         /// <summary>
-        /// Queue a work item
+        /// This event is fired when a thread is created.
+        /// Use it to initialize a thread before the work items use it.
         /// </summary>
-        /// <param name="callback">A callback to execute</param>
-        /// <param name="state">
-        /// The context object of the work item. Used for passing arguments to the work item. 
-        /// </param>
-        /// <param name="postExecuteWorkItemCallback">
-        /// A delegate to call after the callback completion
-        /// </param>
-        /// <returns>Returns a work item result</returns>
-        public IWorkItemResult QueueWorkItem(
-            WorkItemCallback callback, 
-            object state,
-            PostExecuteWorkItemCallback postExecuteWorkItemCallback)
+        public event ThreadInitializationHandler OnThreadInitialization
         {
-            ValidateNotDisposed();
-            ValidateCallback(callback);
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, callback, state, postExecuteWorkItemCallback);
-            Enqueue(workItem);
-            return workItem.GetWorkItemResult();
+            add { _onThreadInitialization += value; }
+            remove { _onThreadInitialization -= value; }
         }
 
         /// <summary>
-        /// Queue a work item
+        /// This event is fired when a thread is terminating.
+        /// Use it for cleanup.
         /// </summary>
-        /// <param name="callback">A callback to execute</param>
-        /// <param name="state">
-        /// The context object of the work item. Used for passing arguments to the work item. 
-        /// </param>
-        /// <param name="postExecuteWorkItemCallback">
-        /// A delegate to call after the callback completion
-        /// </param>
-        /// <param name="workItemPriority">The work item priority</param>
-        /// <returns>Returns a work item result</returns>
-        public IWorkItemResult QueueWorkItem(
-            WorkItemCallback callback, 
-            object state,
-            PostExecuteWorkItemCallback postExecuteWorkItemCallback,
-            WorkItemPriority workItemPriority)
+        public event ThreadTerminationHandler OnThreadTermination
         {
-            ValidateNotDisposed();
-            ValidateCallback(callback);
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, callback, state, postExecuteWorkItemCallback, workItemPriority);
-            Enqueue(workItem);
-            return workItem.GetWorkItemResult();
+            add { _onThreadTermination += value; }
+            remove { _onThreadTermination -= value; }
         }
 
-        /// <summary>
-        /// Queue a work item
-        /// </summary>
-        /// <param name="callback">A callback to execute</param>
-        /// <param name="state">
-        /// The context object of the work item. Used for passing arguments to the work item. 
-        /// </param>
-        /// <param name="postExecuteWorkItemCallback">
-        /// A delegate to call after the callback completion
-        /// </param>
-        /// <param name="callToPostExecute">Indicates on which cases to call to the post execute callback</param>
-        /// <returns>Returns a work item result</returns>
-        public IWorkItemResult QueueWorkItem(
-            WorkItemCallback callback, 
-            object state,
-            PostExecuteWorkItemCallback postExecuteWorkItemCallback,
-            CallToPostExecute callToPostExecute)
-        {
-            ValidateNotDisposed();
-            ValidateCallback(callback);
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, callback, state, postExecuteWorkItemCallback, callToPostExecute);
-            Enqueue(workItem);
-            return workItem.GetWorkItemResult();
-        }
 
-        /// <summary>
-        /// Queue a work item
-        /// </summary>
-        /// <param name="callback">A callback to execute</param>
-        /// <param name="state">
-        /// The context object of the work item. Used for passing arguments to the work item. 
-        /// </param>
-        /// <param name="postExecuteWorkItemCallback">
-        /// A delegate to call after the callback completion
-        /// </param>
-        /// <param name="callToPostExecute">Indicates on which cases to call to the post execute callback</param>
-        /// <param name="workItemPriority">The work item priority</param>
-        /// <returns>Returns a work item result</returns>
-        public IWorkItemResult QueueWorkItem(
-            WorkItemCallback callback, 
-            object state,
-            PostExecuteWorkItemCallback postExecuteWorkItemCallback,
-            CallToPostExecute callToPostExecute,
-            WorkItemPriority workItemPriority)
+        internal void CancelAbortWorkItemsGroup(WorkItemsGroup wig)
         {
-            ValidateNotDisposed();
-            ValidateCallback(callback);
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, callback, state, postExecuteWorkItemCallback, callToPostExecute, workItemPriority);
-            Enqueue(workItem);
-            return workItem.GetWorkItemResult();
+            foreach (ThreadEntry threadEntry in _workerThreads.Values)
+            {
+                WorkItem workItem = threadEntry.CurrentWorkItem;
+                if (null != workItem &&
+                    workItem.WasQueuedBy(wig) &&
+                    !workItem.IsCanceled)
+                {
+                    threadEntry.CurrentWorkItem.GetWorkItemResult().Cancel(true);
+                }
+            }
         }
 
-        /// <summary>
-        /// Wait for the thread pool to be idle
-        /// </summary>
-        public void WaitForIdle()
-        {
-            WaitForIdle(Timeout.Infinite);
-        }
+        
 
-        /// <summary>
-        /// Wait for the thread pool to be idle
-        /// </summary>
-        public bool WaitForIdle(TimeSpan timeout)
-        {
-            return WaitForIdle((int)timeout.TotalMilliseconds);
-        }
+                #endregion
 
-        /// <summary>
-        /// Wait for the thread pool to be idle
-        /// </summary>
-        public bool WaitForIdle(int millisecondsTimeout)
-        {
-            ValidateWaitForIdle();
-            return _isIdleWaitHandle.WaitOne(millisecondsTimeout, false);
-        }
+                #region Properties
 
-        private void ValidateWaitForIdle()
-        {
-            if(_smartThreadPool == this)
+                /// <summary>
+                /// Get/Set the lower limit of threads in the pool.
+                /// </summary>
+                public int MinThreads 
+                { 
+                        get 
+                        {
+                                ValidateNotDisposed();
+                return _stpStartInfo.MinWorkerThreads; 
+                        }
+            set
             {
-                throw new NotSupportedException(
-                    "WaitForIdle cannot be called from a thread on its SmartThreadPool, it will cause may cause a deadlock");
+                Debug.Assert(value >= 0);
+                Debug.Assert(value <= _stpStartInfo.MaxWorkerThreads);
+                if (_stpStartInfo.MaxWorkerThreads < value)
+                {
+                    _stpStartInfo.MaxWorkerThreads = value;
+                }
+                _stpStartInfo.MinWorkerThreads = value;
+                StartOptimalNumberOfThreads();
             }
-        }
+                }
+
+            /// <summary>
+                /// Get/Set the upper limit of threads in the pool.
+                /// </summary>
+                public int MaxThreads 
+                { 
+                        get 
+                        {
+                                ValidateNotDisposed();
+                return _stpStartInfo.MaxWorkerThreads; 
+                        } 
 
-        internal void ValidateWorkItemsGroupWaitForIdle(IWorkItemsGroup workItemsGroup)
+                        set 
+                        {
+                Debug.Assert(value > 0);
+                Debug.Assert(value >= _stpStartInfo.MinWorkerThreads);
+                if (_stpStartInfo.MinWorkerThreads > value)
+                {
+                    _stpStartInfo.MinWorkerThreads = value;
+                }
+                _stpStartInfo.MaxWorkerThreads = value;
+                StartOptimalNumberOfThreads();
+            } 
+                }
+                /// <summary>
+                /// Get the number of threads in the thread pool.
+                /// Should be between the lower and the upper limits.
+                /// </summary>
+                public int ActiveThreads 
+                { 
+                        get 
+                        {
+                                ValidateNotDisposed();
+                                return _workerThreads.Count; 
+                        } 
+                }
+
+                /// <summary>
+                /// Get the number of busy (not idle) threads in the thread pool.
+                /// </summary>
+                public int InUseThreads 
+                { 
+                        get 
+                        { 
+                                ValidateNotDisposed();
+                                return _inUseWorkerThreads; 
+                        } 
+                }
+
+        /// <summary>
+        /// Returns true if the current running work item has been cancelled.
+        /// Must be used within the work item's callback method.
+        /// The work item should sample this value in order to know if it
+        /// needs to quit before its completion.
+        /// </summary>
+        public static bool IsWorkItemCanceled
         {
-            ValidateWorkItemsGroupWaitForIdleImpl(workItemsGroup, SmartThreadPool._currentWorkItem);
-            if ((null != workItemsGroup) && 
-                (null != SmartThreadPool._currentWorkItem) &&
-                SmartThreadPool._currentWorkItem.WasQueuedBy(workItemsGroup))
+            get
             {
-                throw new NotSupportedException("WaitForIdle cannot be called from a thread on its SmartThreadPool, it will cause may cause a deadlock");
+                return CurrentThreadEntry.CurrentWorkItem.IsCanceled;
             }
-        }
-
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private void ValidateWorkItemsGroupWaitForIdleImpl(IWorkItemsGroup workItemsGroup, WorkItem workItem)
+        } 
+        
+        /// <summary>
+        /// Checks if the work item has been cancelled, and if yes then abort the thread.
+        /// Can be used with Cancel and timeout
+        /// </summary>
+        public static void AbortOnWorkItemCancel()
         {
-            if ((null != workItemsGroup) && 
-                (null != workItem) &&
-                workItem.WasQueuedBy(workItemsGroup))
+            if (IsWorkItemCanceled)
             {
-                throw new NotSupportedException("WaitForIdle cannot be called from a thread on its SmartThreadPool, it will cause may cause a deadlock");
+                Thread.CurrentThread.Abort();
             }
         }
 
-
-
         /// <summary>
-        /// Force the SmartThreadPool to shutdown
+        /// Thread Pool start information (readonly)
         /// </summary>
-        public void Shutdown()
+        public STPStartInfo STPStartInfo
         {
-            Shutdown(true, 0);
+            get 
+            {
+                return _stpStartInfo.AsReadOnly(); 
+            }
         }
 
-        public void Shutdown(bool forceAbort, TimeSpan timeout)
-        {
-            Shutdown(forceAbort, (int)timeout.TotalMilliseconds);
-        }
+            public bool IsShuttingdown
+            {
+            get { return _shutdown;  }
+            }
 
         /// <summary>
-        /// Empties the queue of work items and abort the threads in the pool.
+        /// Return the local calculated performance counters
+        /// Available only if STPStartInfo.EnableLocalPerformanceCounters is true.
         /// </summary>
-        public void Shutdown(bool forceAbort, int millisecondsTimeout)
+        public ISTPPerformanceCountersReader PerformanceCountersReader
         {
-            ValidateNotDisposed();
-
-            ISTPInstancePerformanceCounters pcs = _pcs;
-
-            if (NullSTPInstancePerformanceCounters.Instance != _pcs)
-            {
-                _pcs.Dispose();
-                // Set the _pcs to "null" to stop updating the performance
-                // counters
-                _pcs = NullSTPInstancePerformanceCounters.Instance;
-            }
-
-            Thread [] threads = null;
-            lock(_workerThreads.SyncRoot)
-            {
-                // Shutdown the work items queue
-                _workItemsQueue.Dispose();
-
-                // Signal the threads to exit
-                _shutdown = true;
-                _shuttingDownEvent.Set();
+            get { return (ISTPPerformanceCountersReader)_localPCs; }
+        }
 
-                // Make a copy of the threads' references in the pool
-                threads = new Thread [_workerThreads.Count];
-                _workerThreads.Keys.CopyTo(threads, 0);
-            }
+        #endregion
 
-            int millisecondsLeft = millisecondsTimeout;
-            DateTime start = DateTime.Now;
-            bool waitInfinitely = (Timeout.Infinite == millisecondsTimeout);
-            bool timeout = false;
+        #region IDisposable Members
 
-            // Each iteration we update the time left for the timeout.
-            foreach(Thread thread in threads)
+        public void Dispose()
+        {
+            if (!_isDisposed)
             {
-                // Join don't work with negative numbers
-                if (!waitInfinitely && (millisecondsLeft < 0))
+                if (!_shutdown)
                 {
-                    timeout = true;
-                    break;
+                    Shutdown();
                 }
 
-                // Wait for the thread to terminate
-                bool success = thread.Join(millisecondsLeft);
-                if(!success)
+                if (null != _shuttingDownEvent)
                 {
-                    timeout = true;
-                    break;
+                    _shuttingDownEvent.Close();
+                    _shuttingDownEvent = null;
                 }
-
-                if(!waitInfinitely)
+                _workerThreads.Clear();
+                
+                if (null != _isIdleWaitHandle)
                 {
-                    // Update the time left to wait
-                    TimeSpan ts = DateTime.Now - start;
-                    millisecondsLeft = millisecondsTimeout - (int)ts.TotalMilliseconds;
+                    _isIdleWaitHandle.Close();
+                    _isIdleWaitHandle = null;
                 }
-            }
 
-            if (timeout && forceAbort)
-            {
-                // Abort the threads in the pool
-                foreach(Thread thread in threads)
-                {
-                    if ((thread != null) && thread.IsAlive) 
-                    {
-                        try 
-                        {
-                            thread.Abort("Shutdown");
-                        }
-                        catch(SecurityException e)
-                        {
-                            e.GetHashCode();
-                        }
-                        catch(ThreadStateException ex)
-                        {
-                            ex.GetHashCode();
-                            // In case the thread has been terminated 
-                            // after the check if it is alive.
-                        }
-                    }
-                }
+                _isDisposed = true;
             }
-
-            // Dispose of the performance counters
-            pcs.Dispose();
         }
 
-        /// <summary>
-        /// Wait for all work items to complete
-        /// </summary>
-        /// <param name="workItemResults">Array of work item result objects</param>
-        /// <returns>
-        /// true when every work item in workItemResults has completed; otherwise false.
-        /// </returns>
-        public static bool WaitAll(
-            IWorkItemResult [] workItemResults)
+        private void ValidateNotDisposed()
         {
-            return WaitAll(workItemResults, Timeout.Infinite, true);
+            if(_isDisposed)
+            {
+                throw new ObjectDisposedException(GetType().ToString(), "The SmartThreadPool has been shutdown");
+            }
         }
+        #endregion
+
+        #region WorkItemsGroupBase Overrides
 
         /// <summary>
-        /// Wait for all work items to complete
+        /// Get/Set the maximum number of work items that execute cocurrency on the thread pool
         /// </summary>
-        /// <param name="workItemResults">Array of work item result objects</param>
-        /// <param name="timeout">The number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. </param>
-        /// <param name="exitContext">
-        /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
-        /// </param>
-        /// <returns>
-        /// true when every work item in workItemResults has completed; otherwise false.
-        /// </returns>
-        public static bool WaitAll(
-            IWorkItemResult [] workItemResults,
-            TimeSpan timeout,
-            bool exitContext)
-        {
-            return WaitAll(workItemResults, (int)timeout.TotalMilliseconds, exitContext);
-        }
+        public override int Concurrency
+            {
+                get { return MaxThreads; }
+                set { MaxThreads = value; }
+            }
+
+            /// <summary>
+            /// Get the number of work items in the queue.
+            /// </summary>
+            public override int WaitingCallbacks
+            {
+                get
+                {
+                    ValidateNotDisposed();
+                    return _workItemsQueue.Count;
+                }
+            }
 
         /// <summary>
-        /// Wait for all work items to complete
+        /// Get an array with all the state objects of the currently running items.
+        /// The array represents a snap shot and impact performance.
         /// </summary>
-        /// <param name="workItemResults">Array of work item result objects</param>
-        /// <param name="timeout">The number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. </param>
-        /// <param name="exitContext">
-        /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
-        /// </param>
-        /// <param name="cancelWaitHandle">A cancel wait handle to interrupt the wait if needed</param>
-        /// <returns>
-        /// true when every work item in workItemResults has completed; otherwise false.
-        /// </returns>
-        public static bool WaitAll(
-            IWorkItemResult [] workItemResults,  
-            TimeSpan timeout,
-            bool exitContext,
-            WaitHandle cancelWaitHandle)
+        public override object[] GetStates()
         {
-            return WaitAll(workItemResults, (int)timeout.TotalMilliseconds, exitContext, cancelWaitHandle);
+            object[] states = _workItemsQueue.GetStates();
+            return states;
         }
 
         /// <summary>
-        /// Wait for all work items to complete
+        /// WorkItemsGroup start information (readonly)
         /// </summary>
-        /// <param name="workItemResults">Array of work item result objects</param>
-        /// <param name="millisecondsTimeout">The number of milliseconds to wait, or Timeout.Infinite (-1) to wait indefinitely.</param>
-        /// <param name="exitContext">
-        /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
-        /// </param>
-        /// <returns>
-        /// true when every work item in workItemResults has completed; otherwise false.
-        /// </returns>
-        public static bool WaitAll(
-            IWorkItemResult [] workItemResults,  
-            int millisecondsTimeout,
-            bool exitContext)
+        public override WIGStartInfo WIGStartInfo
         {
-            return WorkItem.WaitAll(workItemResults, millisecondsTimeout, exitContext, null);
+            get { return _stpStartInfo.AsReadOnly(); }
         }
 
-        /// <summary>
-        /// Wait for all work items to complete
+            /// <summary>
+        /// Start the thread pool if it was started suspended.
+        /// If it is already running, this method is ignored.
         /// </summary>
-        /// <param name="workItemResults">Array of work item result objects</param>
-        /// <param name="millisecondsTimeout">The number of milliseconds to wait, or Timeout.Infinite (-1) to wait indefinitely.</param>
-        /// <param name="exitContext">
-        /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
-        /// </param>
-        /// <param name="cancelWaitHandle">A cancel wait handle to interrupt the wait if needed</param>
-        /// <returns>
-        /// true when every work item in workItemResults has completed; otherwise false.
-        /// </returns>
-        public static bool WaitAll(
-            IWorkItemResult [] workItemResults,  
-            int millisecondsTimeout,
-            bool exitContext,
-            WaitHandle cancelWaitHandle)
+        public override void Start()
         {
-            return WorkItem.WaitAll(workItemResults, millisecondsTimeout, exitContext, cancelWaitHandle);
-        }
+            if (!_isSuspended)
+            {
+                return;
+            }
+            _isSuspended = false;
 
+            ICollection workItemsGroups = _workItemsGroups.Values;
+            foreach (WorkItemsGroup workItemsGroup in workItemsGroups)
+            {
+                workItemsGroup.OnSTPIsStarting();
+            }
 
-        /// <summary>
-        /// Waits for any of the work items in the specified array to complete, cancel, or timeout
-        /// </summary>
-        /// <param name="workItemResults">Array of work item result objects</param>
-        /// <returns>
-        /// The array index of the work item result that satisfied the wait, or WaitTimeout if any of the work items has been canceled.
-        /// </returns>
-        public static int WaitAny(
-            IWorkItemResult [] workItemResults)
-        {
-            return WaitAny(workItemResults, Timeout.Infinite, true);
+            StartOptimalNumberOfThreads();
         }
 
         /// <summary>
-        /// Waits for any of the work items in the specified array to complete, cancel, or timeout
+        /// Cancel all work items using thread abortion
         /// </summary>
-        /// <param name="workItemResults">Array of work item result objects</param>
-        /// <param name="timeout">The number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. </param>
-        /// <param name="exitContext">
-        /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
-        /// </param>
-        /// <returns>
-        /// The array index of the work item result that satisfied the wait, or WaitTimeout if no work item result satisfied the wait and a time interval equivalent to millisecondsTimeout has passed or the work item has been canceled.
-        /// </returns>
-        public static int WaitAny(
-            IWorkItemResult [] workItemResults,
-            TimeSpan timeout,
-            bool exitContext)
+        /// <param name="abortExecution">True to stop work items by raising ThreadAbortException</param>
+        public override void Cancel(bool abortExecution)
         {
-            return WaitAny(workItemResults, (int)timeout.TotalMilliseconds, exitContext);
-        }
+            _canceledSmartThreadPool.IsCanceled = true;
+            _canceledSmartThreadPool = new CanceledWorkItemsGroup();
 
-        /// <summary>
-        /// Waits for any of the work items in the specified array to complete, cancel, or timeout
-        /// </summary>
-        /// <param name="workItemResults">Array of work item result objects</param>
-        /// <param name="timeout">The number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. </param>
-        /// <param name="exitContext">
-        /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
-        /// </param>
-        /// <param name="cancelWaitHandle">A cancel wait handle to interrupt the wait if needed</param>
-        /// <returns>
-        /// The array index of the work item result that satisfied the wait, or WaitTimeout if no work item result satisfied the wait and a time interval equivalent to millisecondsTimeout has passed or the work item has been canceled.
-        /// </returns>
-        public static int WaitAny(
-            IWorkItemResult [] workItemResults,
-            TimeSpan timeout,
-            bool exitContext,
-            WaitHandle cancelWaitHandle)
-        {
-            return WaitAny(workItemResults, (int)timeout.TotalMilliseconds, exitContext, cancelWaitHandle);
+            ICollection workItemsGroups = _workItemsGroups.Values;
+            foreach (WorkItemsGroup workItemsGroup in workItemsGroups)
+            {
+                workItemsGroup.Cancel(abortExecution);
+            }
+
+            if (abortExecution)
+            {
+                foreach (ThreadEntry threadEntry in _workerThreads.Values)
+                {
+                    WorkItem workItem = threadEntry.CurrentWorkItem;
+                    if (null != workItem &&
+                        threadEntry.AssociatedSmartThreadPool == this &&
+                        !workItem.IsCanceled)
+                    {
+                        threadEntry.CurrentWorkItem.GetWorkItemResult().Cancel(true);
+                    }
+                }
+            }
         }
 
-        /// <summary>
-        /// Waits for any of the work items in the specified array to complete, cancel, or timeout
+            /// <summary>
+        /// Wait for the thread pool to be idle
         /// </summary>
-        /// <param name="workItemResults">Array of work item result objects</param>
-        /// <param name="millisecondsTimeout">The number of milliseconds to wait, or Timeout.Infinite (-1) to wait indefinitely.</param>
-        /// <param name="exitContext">
-        /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
-        /// </param>
-        /// <returns>
-        /// The array index of the work item result that satisfied the wait, or WaitTimeout if no work item result satisfied the wait and a time interval equivalent to millisecondsTimeout has passed or the work item has been canceled.
-        /// </returns>
-        public static int WaitAny(
-            IWorkItemResult [] workItemResults,  
-            int millisecondsTimeout,
-            bool exitContext)
+        public override bool WaitForIdle(int millisecondsTimeout)
         {
-            return WorkItem.WaitAny(workItemResults, millisecondsTimeout, exitContext, null);
+            ValidateWaitForIdle();
+            return STPEventWaitHandle.WaitOne(_isIdleWaitHandle, millisecondsTimeout, false);
         }
 
         /// <summary>
-        /// Waits for any of the work items in the specified array to complete, cancel, or timeout
+        /// This event is fired when all work items are completed.
+        /// (When IsIdle changes to true)
+        /// This event only work on WorkItemsGroup. On SmartThreadPool
+        /// it throws the NotImplementedException.
         /// </summary>
-        /// <param name="workItemResults">Array of work item result objects</param>
-        /// <param name="millisecondsTimeout">The number of milliseconds to wait, or Timeout.Infinite (-1) to wait indefinitely.</param>
-        /// <param name="exitContext">
-        /// true to exit the synchronization domain for the context before the wait (if in a synchronized context), and reacquire it; otherwise, false. 
-        /// </param>
-        /// <param name="cancelWaitHandle">A cancel wait handle to interrupt the wait if needed</param>
-        /// <returns>
-        /// The array index of the work item result that satisfied the wait, or WaitTimeout if no work item result satisfied the wait and a time interval equivalent to millisecondsTimeout has passed or the work item has been canceled.
-        /// </returns>
-        public static int WaitAny(
-            IWorkItemResult [] workItemResults,  
-            int millisecondsTimeout,
-            bool exitContext,
-            WaitHandle cancelWaitHandle)
-        {
-            return WorkItem.WaitAny(workItemResults, millisecondsTimeout, exitContext, cancelWaitHandle);
-        }
-
-        public IWorkItemsGroup CreateWorkItemsGroup(int concurrency)
-        {
-            IWorkItemsGroup workItemsGroup = new WorkItemsGroup(this, concurrency, _stpStartInfo);
-            return workItemsGroup;
-        }
-
-        public IWorkItemsGroup CreateWorkItemsGroup(int concurrency, WIGStartInfo wigStartInfo)
-        {
-            IWorkItemsGroup workItemsGroup = new WorkItemsGroup(this, concurrency, wigStartInfo);
-            return workItemsGroup;
-        }
-
-        public event WorkItemsGroupIdleHandler OnIdle
+        public override event WorkItemsGroupIdleHandler OnIdle
         {
             add
             {
@@ -1280,166 +1618,115 @@ namespace Amib.Threading
             }
         }
 
-        public void Cancel()
-        {
-            ICollection workItemsGroups = _workItemsGroups.Values;
-            foreach(WorkItemsGroup workItemsGroup in workItemsGroups)
-            {
-                workItemsGroup.Cancel();
-            }
-        }
-
-        public void Start()
+            internal override void PreQueueWorkItem()
         {
-            lock (this)
-            {
-                if (!this._stpStartInfo.StartSuspended)
-                {
-                    return;
-                }
-                _stpStartInfo.StartSuspended = false;
-            }
-            
-            ICollection workItemsGroups = _workItemsGroups.Values;
-            foreach(WorkItemsGroup workItemsGroup in workItemsGroups)
-            {
-                workItemsGroup.OnSTPIsStarting();
-            }
-
-            StartOptimalNumberOfThreads();
+            ValidateNotDisposed();   
         }
 
         #endregion
 
-        #region Properties
-
-        /// <summary>
-        /// Get/Set the name of the SmartThreadPool instance
-        /// </summary>
-        public string Name 
-        { 
-            get
-            {
-                return _name;
-            }
-
-            set
-            {
-                _name = value;
-            }
-        }
+        #region Join, Choice, Pipe, etc.
 
         /// <summary>
-        /// Get the lower limit of threads in the pool.
+        /// Executes all actions in parallel.
+        /// Returns when they all finish.
         /// </summary>
-        public int MinThreads 
-        { 
-            get 
+        /// <param name="actions">Actions to execute</param>
+        public void Join(IEnumerable<Action> actions)
+        {
+            WIGStartInfo wigStartInfo = new WIGStartInfo { StartSuspended = true };
+            IWorkItemsGroup workItemsGroup = CreateWorkItemsGroup(int.MaxValue, wigStartInfo);
+            foreach (Action action in actions)
             {
-                ValidateNotDisposed();
-                return _stpStartInfo.MinWorkerThreads; 
+                workItemsGroup.QueueWorkItem(action);
             }
+            workItemsGroup.Start();
+            workItemsGroup.WaitForIdle();
         }
 
         /// <summary>
-        /// Get the upper limit of threads in the pool.
-        /// </summary>
-        public int MaxThreads 
-        { 
-            get 
-            {
-                ValidateNotDisposed();
-                return _stpStartInfo.MaxWorkerThreads; 
-            } 
-        }
-        /// <summary>
-        /// Get the number of threads in the thread pool.
-        /// Should be between the lower and the upper limits.
+        /// Executes all actions in parallel.
+        /// Returns when they all finish.
         /// </summary>
-        public int ActiveThreads 
-        { 
-            get 
-            {
-                ValidateNotDisposed();
-                return _workerThreads.Count; 
-            } 
+        /// <param name="actions">Actions to execute</param>
+        public void Join(params Action[] actions)
+        {
+            Join((IEnumerable<Action>)actions);
         }
 
-        /// <summary>
-        /// Get the number of busy (not idle) threads in the thread pool.
-        /// </summary>
-        public int InUseThreads 
-        { 
-            get 
-            { 
-                ValidateNotDisposed();
-                return _inUseWorkerThreads; 
-            } 
+        private class ChoiceIndex
+        {
+            public int _index = -1;
         }
 
         /// <summary>
-        /// Get the number of work items in the queue.
+        /// Executes all actions in parallel
+        /// Returns when the first one completes
         /// </summary>
-        public int WaitingCallbacks 
-        { 
-            get 
-            { 
-                ValidateNotDisposed();
-                return _workItemsQueue.Count;
-            } 
-        }
+        /// <param name="actions">Actions to execute</param>
+        public int Choice(IEnumerable<Action> actions)
+        {
+            WIGStartInfo wigStartInfo = new WIGStartInfo { StartSuspended = true };
+            IWorkItemsGroup workItemsGroup = CreateWorkItemsGroup(int.MaxValue, wigStartInfo);
 
+            ManualResetEvent anActionCompleted = new ManualResetEvent(false);
 
-        public event EventHandler Idle
-        {
-            add
+            ChoiceIndex choiceIndex = new ChoiceIndex();
+            
+            int i = 0;
+            foreach (Action action in actions)
             {
-                _stpIdle += value;
+                Action act = action;
+                int value = i;
+                workItemsGroup.QueueWorkItem(() => { act(); Interlocked.CompareExchange(ref choiceIndex._index, value, -1); anActionCompleted.Set(); });
+                ++i;
             }
+                workItemsGroup.Start();
+            anActionCompleted.WaitOne();
 
-            remove
-            {
-                _stpIdle -= value;
-            }
+            return choiceIndex._index;
         }
 
-        #endregion
-
-        #region IDisposable Members
-
-//        ~SmartThreadPool()
-//        {
-//            Dispose();
-//        }
+        /// <summary>
+        /// Executes all actions in parallel
+        /// Returns when the first one completes
+        /// </summary>
+        /// <param name="actions">Actions to execute</param>
+        public int Choice(params Action[] actions)
+            {
+            return Choice((IEnumerable<Action>)actions);
+        }
 
-        public void Dispose()
+        /// <summary>
+        /// Executes actions in sequence asynchronously.
+        /// Returns immediately.
+        /// </summary>
+        /// <param name="pipeState">A state context that passes </param>
+        /// <param name="actions">Actions to execute in the order they should run</param>
+        public void Pipe<T>(T pipeState, IEnumerable<Action<T>> actions)
         {
-            if (!_isDisposed)
+            WIGStartInfo wigStartInfo = new WIGStartInfo { StartSuspended = true };
+            IWorkItemsGroup workItemsGroup = CreateWorkItemsGroup(1, wigStartInfo);
+            foreach (Action<T> action in actions)
             {
-                if (!_shutdown)
-                {
-                    Shutdown();
-                }
-
-                if (null != _shuttingDownEvent)
-                {
-                    _shuttingDownEvent.Close();
-                    _shuttingDownEvent = null;
-                }
-                _workerThreads.Clear();
-                _isDisposed = true;
-                GC.SuppressFinalize(this);
+                Action<T> act = action;
+                workItemsGroup.QueueWorkItem(() => act(pipeState));
             }
+            workItemsGroup.Start();
+            workItemsGroup.WaitForIdle();
         }
 
-        private void ValidateNotDisposed()
+        /// <summary>
+        /// Executes actions in sequence asynchronously.
+        /// Returns immediately.
+        /// </summary>
+        /// <param name="pipeState"></param>
+        /// <param name="actions">Actions to execute in the order they should run</param>
+        public void Pipe<T>(T pipeState, params Action<T>[] actions)
         {
-            if(_isDisposed)
-            {
-                throw new ObjectDisposedException(GetType().ToString(), "The SmartThreadPool has been shutdown");
-            }
+            Pipe(pipeState, (IEnumerable<Action<T>>)actions);
         }
         #endregion
-    }
-    #endregion
+        }
+        #endregion
 }