* This is Melanie's XEngine script engine. I've not tested this real well, however, it's confirmed to compile and OpenSimulator to run successfully without this script engine active.

14 files changed, 5446 insertions, 0 deletions

diff --git a/ThirdParty/SmartThreadPool/AssemblyInfo.cs b/ThirdParty/SmartThreadPool/AssemblyInfo.cs
new file mode 100644
index 0000000..765bd30
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/AssemblyInfo.cs
@@ -0,0 +1,61 @@
+using System;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+//
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+//
+[assembly: AssemblyTitle("")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]        
+[assembly: ComVisible(false)]
+[assembly: CLSCompliant(true)]
+
+//
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+
+[assembly: AssemblyVersion("1.0.*")]
+
+//
+// In order to sign your assembly you must specify a key to use. Refer to the 
+// Microsoft .NET Framework documentation for more information on assembly signing.
+//
+// Use the attributes below to control which key is used for signing. 
+//
+// Notes: 
+//   (*) If no key is specified, the assembly is not signed.
+//   (*) KeyName refers to a key that has been installed in the Crypto Service
+//       Provider (CSP) on your machine. KeyFile refers to a file which contains
+//       a key.
+//   (*) If the KeyFile and the KeyName values are both specified, the 
+//       following processing occurs:
+//       (1) If the KeyName can be found in the CSP, that key is used.
+//       (2) If the KeyName does not exist and the KeyFile does exist, the key 
+//           in the KeyFile is installed into the CSP and used.
+//   (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
+//       When specifying the KeyFile, the location of the KeyFile should be
+//       relative to the project output directory which is
+//       %Project Directory%\obj\<configuration>. For example, if your KeyFile is
+//       located in the project directory, you would specify the AssemblyKeyFile 
+//       attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
+//   (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
+//       documentation for more information on this.
+//
+[assembly: AssemblyDelaySign(false)]
+[assembly: AssemblyKeyFile("")]
+[assembly: AssemblyKeyName("")]
diff --git a/ThirdParty/SmartThreadPool/CallerThreadContext.cs b/ThirdParty/SmartThreadPool/CallerThreadContext.cs
new file mode 100644
index 0000000..6ea53f6
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/CallerThreadContext.cs
@@ -0,0 +1,223 @@
+using System;
+using System.Diagnostics;
+using System.Threading;
+using System.Reflection;
+using System.Web;
+using System.Runtime.Remoting.Messaging;
+
+
+namespace Amib.Threading
+{
+    #region CallerThreadContext class
+
+    /// <summary>
+    /// This class stores the caller call context in order to restore
+    /// it when the work item is executed in the thread pool environment. 
+    /// </summary>
+    internal class CallerThreadContext 
+    {
+        #region Prepare reflection information
+
+        // Cached type information.
+        private static MethodInfo getLogicalCallContextMethodInfo =
+            typeof(Thread).GetMethod("GetLogicalCallContext", BindingFlags.Instance | BindingFlags.NonPublic);
+
+        private static MethodInfo setLogicalCallContextMethodInfo =
+            typeof(Thread).GetMethod("SetLogicalCallContext", BindingFlags.Instance | BindingFlags.NonPublic);
+
+        private static string HttpContextSlotName = GetHttpContextSlotName();
+
+        private static string GetHttpContextSlotName()
+        {
+            FieldInfo fi = typeof(HttpContext).GetField("CallContextSlotName", BindingFlags.Static | BindingFlags.NonPublic);
+
+            if( fi != null )
+                return (string)fi.GetValue(null);
+            else // Use the default "HttpContext" slot name
+                return "HttpContext";
+        }
+
+        #endregion
+
+        #region Private fields
+
+        private HttpContext _httpContext = null;
+        private LogicalCallContext _callContext = null;
+
+        #endregion
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        private CallerThreadContext()
+        {
+        }
+
+        public bool CapturedCallContext
+        {
+            get
+            {
+                return (null != _callContext);
+            }
+        }
+
+        public bool CapturedHttpContext
+        {
+            get
+            {
+                return (null != _httpContext);
+            }
+        }
+
+        /// <summary>
+        /// Captures the current thread context
+        /// </summary>
+        /// <returns></returns>
+        public static CallerThreadContext Capture(
+            bool captureCallContext, 
+            bool captureHttpContext)
+        {
+            Debug.Assert(captureCallContext || captureHttpContext);
+
+            CallerThreadContext callerThreadContext = new CallerThreadContext();
+
+            // TODO: In NET 2.0, redo using the new feature of ExecutionContext class - Capture()
+            // Capture Call Context
+            if(captureCallContext && (getLogicalCallContextMethodInfo != null))
+            {
+                callerThreadContext._callContext = (LogicalCallContext)getLogicalCallContextMethodInfo.Invoke(Thread.CurrentThread, null);
+                if (callerThreadContext._callContext != null)
+                {
+                    callerThreadContext._callContext = (LogicalCallContext)callerThreadContext._callContext.Clone();
+                }
+            }
+
+            // Capture httpContext
+            if (captureHttpContext && (null != HttpContext.Current))
+            {
+                callerThreadContext._httpContext = HttpContext.Current;
+            }
+
+            return callerThreadContext;
+        }
+
+        /// <summary>
+        /// Applies the thread context stored earlier
+        /// </summary>
+        /// <param name="callerThreadContext"></param>
+        public static void Apply(CallerThreadContext callerThreadContext)
+        {
+            if (null == callerThreadContext) 
+            {
+                throw new ArgumentNullException("callerThreadContext");            
+            }
+
+            // Todo: In NET 2.0, redo using the new feature of ExecutionContext class - Run()
+            // Restore call context
+            if ((callerThreadContext._callContext != null) && (setLogicalCallContextMethodInfo != null))
+            {
+                setLogicalCallContextMethodInfo.Invoke(Thread.CurrentThread, new object[] { callerThreadContext._callContext });
+            }
+
+            // Restore HttpContext 
+            if (callerThreadContext._httpContext != null)
+            {
+                CallContext.SetData(HttpContextSlotName, callerThreadContext._httpContext);
+            }
+        }
+    }
+
+    #endregion
+
+}
+
+
+/*
+// Ami Bar
+// amibar@gmail.com
+
+using System;
+using System.Threading;
+using System.Globalization;
+using System.Security.Principal;
+using System.Reflection;
+using System.Runtime.Remoting.Contexts;
+
+namespace Amib.Threading.Internal
+{
+    #region CallerThreadContext class
+
+    /// <summary>
+    /// This class stores the caller thread context in order to restore
+    /// it when the work item is executed in the context of the thread 
+    /// from the pool.
+    /// Note that we can't store the thread's CompressedStack, because 
+    /// it throws a security exception
+    /// </summary>
+    public class CallerThreadContext
+    {
+        private CultureInfo _culture = null;
+        private CultureInfo _cultureUI = null;
+        private IPrincipal _principal;
+        private System.Runtime.Remoting.Contexts.Context _context;
+
+        private static FieldInfo _fieldInfo = GetFieldInfo();
+
+        private static FieldInfo GetFieldInfo()
+        {
+            Type threadType = typeof(Thread);
+            return threadType.GetField(
+                "m_Context",
+                BindingFlags.Instance | BindingFlags.NonPublic);
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        private CallerThreadContext()
+        {
+        }
+
+        /// <summary>
+        /// Captures the current thread context
+        /// </summary>
+        /// <returns></returns>
+        public static CallerThreadContext Capture()
+        {
+            CallerThreadContext callerThreadContext = new CallerThreadContext();
+
+            Thread thread = Thread.CurrentThread;
+            callerThreadContext._culture = thread.CurrentCulture;
+            callerThreadContext._cultureUI = thread.CurrentUICulture;
+            callerThreadContext._principal = Thread.CurrentPrincipal;
+            callerThreadContext._context = Thread.CurrentContext;
+            return callerThreadContext;
+        }
+
+        /// <summary>
+        /// Applies the thread context stored earlier
+        /// </summary>
+        /// <param name="callerThreadContext"></param>
+        public static void Apply(CallerThreadContext callerThreadContext)
+        {
+            Thread thread = Thread.CurrentThread;
+            thread.CurrentCulture = callerThreadContext._culture;
+            thread.CurrentUICulture = callerThreadContext._cultureUI;
+            Thread.CurrentPrincipal = callerThreadContext._principal;
+
+            // Uncomment the following block to enable the Thread.CurrentThread
+/*
+            if (null != _fieldInfo)
+            {
+                _fieldInfo.SetValue(
+                    Thread.CurrentThread, 
+                    callerThreadContext._context);
+            }
+* /            
+        }
+    }
+
+    #endregion
+}
+*/
+
diff --git a/ThirdParty/SmartThreadPool/Exceptions.cs b/ThirdParty/SmartThreadPool/Exceptions.cs
new file mode 100644
index 0000000..c454709
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/Exceptions.cs
@@ -0,0 +1,81 @@
+// Ami Bar
+// amibar@gmail.com
+
+using System;
+using System.Runtime.Serialization;
+
+namespace Amib.Threading
+{
+    #region Exceptions
+
+    /// <summary>
+    /// Represents an exception in case IWorkItemResult.GetResult has been canceled
+    /// </summary>
+    [Serializable]
+    public sealed class WorkItemCancelException : ApplicationException
+    {
+        public WorkItemCancelException() : base()
+        {
+        }
+
+        public WorkItemCancelException(string message) : base(message)
+        {
+        }
+
+        public WorkItemCancelException(string message, Exception e) : base(message, e)
+        {
+        }
+
+        public WorkItemCancelException(SerializationInfo si, StreamingContext sc) : base(si, sc)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Represents an exception in case IWorkItemResult.GetResult has been timed out
+    /// </summary>
+    [Serializable]
+    public sealed class WorkItemTimeoutException : ApplicationException
+    {
+        public WorkItemTimeoutException() : base()
+        {
+        }
+
+        public WorkItemTimeoutException(string message) : base(message)
+        {
+        }
+
+        public WorkItemTimeoutException(string message, Exception e) : base(message, e)
+        {
+        }
+
+        public WorkItemTimeoutException(SerializationInfo si, StreamingContext sc) : base(si, sc)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Represents an exception in case IWorkItemResult.GetResult has been timed out
+    /// </summary>
+    [Serializable]
+    public sealed class WorkItemResultException : ApplicationException
+    {
+        public WorkItemResultException() : base()
+        {
+        }
+
+        public WorkItemResultException(string message) : base(message)
+        {
+        }
+
+        public WorkItemResultException(string message, Exception e) : base(message, e)
+        {
+        }
+
+        public WorkItemResultException(SerializationInfo si, StreamingContext sc) : base(si, sc)
+        {
+        }
+    }
+
+    #endregion
+}
diff --git a/ThirdParty/SmartThreadPool/Interfaces.cs b/ThirdParty/SmartThreadPool/Interfaces.cs
new file mode 100644
index 0000000..f1c1fcf
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/Interfaces.cs
@@ -0,0 +1,271 @@
+// Ami Bar
+// amibar@gmail.com
+
+using System;
+using System.Threading;
+
+namespace Amib.Threading
+{
+    #region Delegates
+
+    /// <summary>
+    /// A delegate that represents the method to run as the work item
+    /// </summary>
+    /// <param name="state">A state object for the method to run</param>
+    public delegate object WorkItemCallback(object state);
+
+    /// <summary>
+    /// A delegate to call after the WorkItemCallback completed
+    /// </summary>
+    /// <param name="wir">The work item result object</param>
+    public delegate void PostExecuteWorkItemCallback(IWorkItemResult wir);
+
+    /// <summary>
+    /// A delegate to call when a WorkItemsGroup becomes idle
+    /// </summary>
+    /// <param name="workItemsGroup">A reference to the WorkItemsGroup that became idle</param>
+    public delegate void WorkItemsGroupIdleHandler(IWorkItemsGroup workItemsGroup);
+
+    #endregion
+
+    #region WorkItem Priority
+
+    public enum WorkItemPriority
+    {
+        Lowest,
+        BelowNormal,
+        Normal,
+        AboveNormal,
+        Highest,
+    }
+
+    #endregion
+
+    #region IHasWorkItemPriority interface 
+
+    public interface IHasWorkItemPriority
+    {
+        WorkItemPriority WorkItemPriority { get; }
+    }
+
+    #endregion
+
+    #region IWorkItemsGroup interface 
+
+    /// <summary>
+    /// IWorkItemsGroup interface
+    /// </summary>
+    public interface IWorkItemsGroup
+    {
+        /// <summary>
+        /// Get/Set the name of the WorkItemsGroup
+        /// </summary>
+        string Name { get; set; }
+
+        IWorkItemResult QueueWorkItem(WorkItemCallback callback);
+        IWorkItemResult QueueWorkItem(WorkItemCallback callback, WorkItemPriority workItemPriority);
+        IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state);
+        IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state, WorkItemPriority workItemPriority);
+        IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state, PostExecuteWorkItemCallback postExecuteWorkItemCallback);
+        IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state, PostExecuteWorkItemCallback postExecuteWorkItemCallback, WorkItemPriority workItemPriority);
+        IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state, PostExecuteWorkItemCallback postExecuteWorkItemCallback, CallToPostExecute callToPostExecute);
+        IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state, PostExecuteWorkItemCallback postExecuteWorkItemCallback, CallToPostExecute callToPostExecute, WorkItemPriority workItemPriority);
+
+        IWorkItemResult QueueWorkItem(WorkItemInfo workItemInfo, WorkItemCallback callback);
+        IWorkItemResult QueueWorkItem(WorkItemInfo workItemInfo, WorkItemCallback callback, object state);
+
+        void WaitForIdle();
+        bool WaitForIdle(TimeSpan timeout);
+        bool WaitForIdle(int millisecondsTimeout);
+
+        int WaitingCallbacks { get; }
+        event WorkItemsGroupIdleHandler OnIdle;
+
+        void Cancel();
+        void Start();
+    }
+
+    #endregion
+
+    #region CallToPostExecute enumerator
+
+    [Flags]
+    public enum CallToPostExecute
+    {
+        Never                    = 0x00,
+        WhenWorkItemCanceled     = 0x01,
+        WhenWorkItemNotCanceled  = 0x02,
+        Always                   = WhenWorkItemCanceled | WhenWorkItemNotCanceled,
+    }
+
+    #endregion
+
+    #region IWorkItemResult interface
+
+    /// <summary>
+    /// IWorkItemResult interface
+    /// </summary>
+    public interface IWorkItemResult
+    {
+        /// <summary>
+        /// Get the result of the work item.
+        /// If the work item didn't run yet then the caller waits.
+        /// </summary>
+        /// <returns>The result of the work item</returns>
+        object GetResult();
+
+        /// <summary>
+        /// Get the result of the work item.
+        /// If the work item didn't run yet then the caller waits until timeout.
+        /// </summary>
+        /// <returns>The result of the work item</returns>
+        /// On timeout throws WorkItemTimeoutException
+        object GetResult(
+            int millisecondsTimeout,
+            bool exitContext);
+
+        /// <summary>
+        /// Get the result of the work item.
+        /// If the work item didn't run yet then the caller waits until timeout.
+        /// </summary>
+        /// <returns>The result of the work item</returns>
+        /// On timeout throws WorkItemTimeoutException
+        object GetResult(            
+            TimeSpan timeout,
+            bool exitContext);
+
+        void Abort();
+
+        /// <summary>
+        /// Get the result of the work item.
+        /// If the work item didn't run yet then the caller waits until timeout or until the cancelWaitHandle is signaled.
+        /// </summary>
+        /// <param name="millisecondsTimeout">Timeout in milliseconds, or -1 for infinite</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 blocking if needed</param>
+        /// <returns>The result of the work item</returns>
+        /// On timeout throws WorkItemTimeoutException
+        /// On cancel throws WorkItemCancelException
+        object GetResult(            
+            int millisecondsTimeout,
+            bool exitContext,
+            WaitHandle cancelWaitHandle);
+
+        /// <summary>
+        /// Get the result of the work item.
+        /// If the work item didn't run yet then the caller waits until timeout or until the cancelWaitHandle is signaled.
+        /// </summary>
+        /// <returns>The result of the work item</returns>
+        /// On timeout throws WorkItemTimeoutException
+        /// On cancel throws WorkItemCancelException
+        object GetResult(            
+            TimeSpan timeout,
+            bool exitContext,
+            WaitHandle cancelWaitHandle);
+
+        /// <summary>
+        /// Get the result of the work item.
+        /// If the work item didn't run yet then the caller waits.
+        /// </summary>
+        /// <param name="e">Filled with the exception if one was thrown</param>
+        /// <returns>The result of the work item</returns>
+        object GetResult(out Exception e);
+
+        /// <summary>
+        /// Get the result of the work item.
+        /// If the work item didn't run yet then the caller waits until timeout.
+        /// </summary>
+        /// <param name="e">Filled with the exception if one was thrown</param>
+        /// <returns>The result of the work item</returns>
+        /// On timeout throws WorkItemTimeoutException
+        object GetResult(
+            int millisecondsTimeout,
+            bool exitContext,
+            out Exception e);
+
+        /// <summary>
+        /// Get the result of the work item.
+        /// If the work item didn't run yet then the caller waits until timeout.
+        /// </summary>
+        /// <param name="e">Filled with the exception if one was thrown</param>
+        /// <returns>The result of the work item</returns>
+        /// On timeout throws WorkItemTimeoutException
+        object GetResult(            
+            TimeSpan timeout,
+            bool exitContext,
+            out Exception e);
+
+        /// <summary>
+        /// Get the result of the work item.
+        /// If the work item didn't run yet then the caller waits until timeout or until the cancelWaitHandle is signaled.
+        /// </summary>
+        /// <param name="millisecondsTimeout">Timeout in milliseconds, or -1 for infinite</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 blocking if needed</param>
+        /// <param name="e">Filled with the exception if one was thrown</param>
+        /// <returns>The result of the work item</returns>
+        /// On timeout throws WorkItemTimeoutException
+        /// On cancel throws WorkItemCancelException
+        object GetResult(            
+            int millisecondsTimeout,
+            bool exitContext,
+            WaitHandle cancelWaitHandle,
+            out Exception e);
+
+        /// <summary>
+        /// Get the result of the work item.
+        /// If the work item didn't run yet then the caller waits until timeout or until the cancelWaitHandle is signaled.
+        /// </summary>
+        /// <returns>The result of the work item</returns>
+        /// <param name="e">Filled with the exception if one was thrown</param>
+        /// On timeout throws WorkItemTimeoutException
+        /// On cancel throws WorkItemCancelException
+        object GetResult(            
+            TimeSpan timeout,
+            bool exitContext,
+            WaitHandle cancelWaitHandle,
+            out Exception e);
+
+        /// <summary>
+        /// Gets an indication whether the asynchronous operation has completed.
+        /// </summary>
+        bool IsCompleted { get; }
+
+        /// <summary>
+        /// Gets an indication whether the asynchronous operation has been canceled.
+        /// </summary>
+        bool IsCanceled { get; }
+
+        /// <summary>
+        /// Gets a user-defined object that qualifies or contains information about an asynchronous operation.
+        /// </summary>
+        object State { get; }
+
+        /// <summary>
+        /// Cancel the work item if it didn't start running yet.
+        /// </summary>
+        /// <returns>Returns true on success or false if the work item is in progress or already completed</returns>
+        bool Cancel();
+
+        /// <summary>
+        /// Get the work item's priority
+        /// </summary>
+        WorkItemPriority WorkItemPriority { get; }
+
+        /// <summary>
+        /// Return the result, same as GetResult()
+        /// </summary>
+        object Result { get; }
+
+        /// <summary>
+        /// Returns the exception if occured otherwise returns null.
+        /// </summary>
+        object Exception { get; }
+    }
+
+    #endregion
+}
diff --git a/ThirdParty/SmartThreadPool/PriorityQueue.cs b/ThirdParty/SmartThreadPool/PriorityQueue.cs
new file mode 100644
index 0000000..63d5e84
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/PriorityQueue.cs
@@ -0,0 +1,240 @@
+// Ami Bar
+// amibar@gmail.com
+
+using System;
+using System.Collections;
+using System.Diagnostics;
+
+namespace Amib.Threading.Internal
+{
+    #region PriorityQueue class
+
+    /// <summary>
+    /// PriorityQueue class
+    /// This class is not thread safe because we use external lock
+    /// </summary>
+    public sealed class PriorityQueue : IEnumerable
+    {
+        #region Private members
+
+        /// <summary>
+        /// The number of queues, there is one for each type of priority
+        /// </summary>
+        private const int _queuesCount = WorkItemPriority.Highest-WorkItemPriority.Lowest+1;
+
+        /// <summary>
+        /// Work items queues. There is one for each type of priority
+        /// </summary>
+        private Queue [] _queues = new Queue[_queuesCount];
+
+        /// <summary>
+        /// The total number of work items within the queues 
+        /// </summary>
+        private int _workItemsCount = 0;
+
+        /// <summary>
+        /// Use with IEnumerable interface
+        /// </summary>
+        private int _version = 0;
+
+        #endregion
+
+        #region Contructor
+
+        public PriorityQueue()
+        {
+            for(int i = 0; i < _queues.Length; ++i)
+            {
+                _queues[i] = new Queue();
+            }
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        /// Enqueue a work item.
+        /// </summary>
+        /// <param name="workItem">A work item</param>
+        public void Enqueue(IHasWorkItemPriority workItem)
+        {
+            Debug.Assert(null != workItem);
+
+            int queueIndex = _queuesCount-(int)workItem.WorkItemPriority-1;
+            Debug.Assert(queueIndex >= 0);
+            Debug.Assert(queueIndex < _queuesCount);
+
+            _queues[queueIndex].Enqueue(workItem);
+            ++_workItemsCount;
+            ++_version;
+        }
+
+        /// <summary>
+        /// Dequeque a work item.
+        /// </summary>
+        /// <returns>Returns the next work item</returns>
+        public IHasWorkItemPriority Dequeue()
+        {
+            IHasWorkItemPriority workItem = null;
+
+            if(_workItemsCount > 0)
+            {
+                int queueIndex = GetNextNonEmptyQueue(-1);
+                Debug.Assert(queueIndex >= 0);
+                workItem = _queues[queueIndex].Dequeue() as IHasWorkItemPriority;
+                Debug.Assert(null != workItem);
+                --_workItemsCount;
+                ++_version;
+            }
+
+            return workItem;
+        }
+
+        /// <summary>
+        /// Find the next non empty queue starting at queue queueIndex+1
+        /// </summary>
+        /// <param name="queueIndex">The index-1 to start from</param>
+        /// <returns>
+        /// The index of the next non empty queue or -1 if all the queues are empty
+        /// </returns>
+        private int GetNextNonEmptyQueue(int queueIndex)
+        {
+            for(int i = queueIndex+1; i < _queuesCount; ++i)
+            {
+                if(_queues[i].Count > 0)
+                {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        /// <summary>
+        /// The number of work items 
+        /// </summary>
+        public int Count
+        {
+            get
+            {
+                return _workItemsCount;
+            }
+        }
+
+        /// <summary>
+        /// Clear all the work items 
+        /// </summary>
+        public void Clear()
+        {
+            if (_workItemsCount > 0)
+            {
+                foreach(Queue queue in _queues)
+                {
+                    queue.Clear();
+                }
+                _workItemsCount = 0;
+                ++_version;
+            }
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        /// <summary>
+        /// Returns an enumerator to iterate over the work items
+        /// </summary>
+        /// <returns>Returns an enumerator</returns>
+        public IEnumerator GetEnumerator()
+        {
+            return new PriorityQueueEnumerator(this);
+        }
+
+        #endregion
+
+        #region PriorityQueueEnumerator
+
+        /// <summary>
+        /// The class the implements the enumerator
+        /// </summary>
+        private class PriorityQueueEnumerator : IEnumerator
+        {
+            private PriorityQueue _priorityQueue;
+            private int _version;
+            private int _queueIndex;
+            private IEnumerator _enumerator;
+
+            public PriorityQueueEnumerator(PriorityQueue priorityQueue)
+            {
+                _priorityQueue = priorityQueue;
+                _version = _priorityQueue._version;
+                _queueIndex = _priorityQueue.GetNextNonEmptyQueue(-1);
+                if (_queueIndex >= 0)
+                {
+                    _enumerator = _priorityQueue._queues[_queueIndex].GetEnumerator();
+                }
+                else
+                {
+                    _enumerator = null;
+                }
+            }
+
+            #region IEnumerator Members
+
+            public void Reset()
+            {
+                _version = _priorityQueue._version;
+                _queueIndex = _priorityQueue.GetNextNonEmptyQueue(-1);
+                if (_queueIndex >= 0)
+                {
+                    _enumerator = _priorityQueue._queues[_queueIndex].GetEnumerator();
+                }
+                else
+                {
+                    _enumerator = null;
+                }
+            }
+
+            public object Current
+            {
+                get
+                {
+                    Debug.Assert(null != _enumerator);
+                    return _enumerator.Current;
+                }
+            }
+
+            public bool MoveNext()
+            {
+                if (null == _enumerator)
+                {
+                    return false;
+                }
+
+                if(_version != _priorityQueue._version)
+                {
+                    throw new InvalidOperationException("The collection has been modified");
+
+                }
+                if (!_enumerator.MoveNext())
+                {
+                    _queueIndex = _priorityQueue.GetNextNonEmptyQueue(_queueIndex);
+                    if(-1 == _queueIndex)
+                    {
+                        return false;
+                    }
+                    _enumerator = _priorityQueue._queues[_queueIndex].GetEnumerator();
+                    _enumerator.MoveNext();
+                    return true;
+                }
+                return true;
+            }
+
+            #endregion
+        }
+
+        #endregion
+    }
+
+    #endregion
+}
diff --git a/ThirdParty/SmartThreadPool/STPPerformanceCounter.cs b/ThirdParty/SmartThreadPool/STPPerformanceCounter.cs
new file mode 100644
index 0000000..be70aea
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/STPPerformanceCounter.cs
@@ -0,0 +1,352 @@
+using System;
+using System.Diagnostics;
+
+namespace Amib.Threading.Internal
+{
+    internal enum STPPerformanceCounterType
+    {
+        // Fields
+        ActiveThreads                = 0,
+        InUseThreads                = 1,
+        OverheadThreads                = 2,
+        OverheadThreadsPercent        = 3,
+        OverheadThreadsPercentBase    = 4,
+
+        WorkItems                    = 5,
+        WorkItemsInQueue            = 6,
+        WorkItemsProcessed            = 7,
+
+        WorkItemsQueuedPerSecond    = 8,
+        WorkItemsProcessedPerSecond    = 9,
+
+        AvgWorkItemWaitTime            = 10,
+        AvgWorkItemWaitTimeBase        = 11,
+
+        AvgWorkItemProcessTime        = 12,
+        AvgWorkItemProcessTimeBase    = 13,
+
+        WorkItemsGroups                = 14,
+
+        LastCounter                    = 14,
+    }
+ 
+
+    /// <summary>
+    /// Summary description for STPPerformanceCounter.
+    /// </summary>
+    internal class STPPerformanceCounter
+    {
+        // Fields
+        private PerformanceCounterType _pcType;
+        protected string _counterHelp;
+        protected string _counterName;
+
+        // Methods
+        public STPPerformanceCounter(
+            string counterName, 
+            string counterHelp, 
+            PerformanceCounterType pcType)
+        {
+            this._counterName = counterName;
+            this._counterHelp = counterHelp;
+            this._pcType = pcType;
+        }
+
+        public void AddCounterToCollection(CounterCreationDataCollection counterData)
+        {
+            CounterCreationData counterCreationData = new CounterCreationData(
+                _counterName, 
+                _counterHelp, 
+                _pcType);
+
+            counterData.Add(counterCreationData);
+        }
+ 
+        // Properties
+        public string Name
+        {
+            get
+            {
+                return _counterName;
+            }
+        }
+    }
+
+    internal class STPPerformanceCounters
+    {
+        // Fields
+        internal STPPerformanceCounter[] _stpPerformanceCounters;
+        private static STPPerformanceCounters _instance;
+        internal const string _stpCategoryHelp = "SmartThreadPool performance counters";
+        internal const string _stpCategoryName = "SmartThreadPool";
+
+        // Methods
+        static STPPerformanceCounters()
+        {
+            _instance = new STPPerformanceCounters();
+        }
+ 
+        private STPPerformanceCounters()
+        {
+            STPPerformanceCounter[] stpPerformanceCounters = new STPPerformanceCounter[] 
+                { 
+                    new STPPerformanceCounter("Active threads", "The current number of available in the thread pool.", PerformanceCounterType.NumberOfItems32), 
+                    new STPPerformanceCounter("In use threads", "The current number of threads that execute a work item.", PerformanceCounterType.NumberOfItems32), 
+                    new STPPerformanceCounter("Overhead threads", "The current number of threads that are active, but are not in use.", PerformanceCounterType.NumberOfItems32), 
+                    new STPPerformanceCounter("% overhead threads", "The current number of threads that are active, but are not in use in percents.", PerformanceCounterType.RawFraction), 
+                    new STPPerformanceCounter("% overhead threads base", "The current number of threads that are active, but are not in use in percents.", PerformanceCounterType.RawBase), 
+
+                    new STPPerformanceCounter("Work Items", "The number of work items in the Smart Thread Pool. Both queued and processed.", PerformanceCounterType.NumberOfItems32), 
+                    new STPPerformanceCounter("Work Items in queue", "The current number of work items in the queue", PerformanceCounterType.NumberOfItems32), 
+                    new STPPerformanceCounter("Work Items processed", "The number of work items already processed", PerformanceCounterType.NumberOfItems32), 
+
+                    new STPPerformanceCounter("Work Items queued/sec", "The number of work items queued per second", PerformanceCounterType.RateOfCountsPerSecond32), 
+                    new STPPerformanceCounter("Work Items processed/sec", "The number of work items processed per second", PerformanceCounterType.RateOfCountsPerSecond32), 
+
+                    new STPPerformanceCounter("Avg. Work Item wait time/sec", "The average time a work item supends in the queue waiting for its turn to execute.", PerformanceCounterType.AverageCount64), 
+                    new STPPerformanceCounter("Avg. Work Item wait time base", "The average time a work item supends in the queue waiting for its turn to execute.", PerformanceCounterType.AverageBase), 
+
+                    new STPPerformanceCounter("Avg. Work Item process time/sec", "The average time it takes to process a work item.", PerformanceCounterType.AverageCount64), 
+                    new STPPerformanceCounter("Avg. Work Item process time base", "The average time it takes to process a work item.", PerformanceCounterType.AverageBase), 
+
+                    new STPPerformanceCounter("Work Items Groups", "The current number of work item groups associated with the Smart Thread Pool.", PerformanceCounterType.NumberOfItems32), 
+                };
+
+            _stpPerformanceCounters = stpPerformanceCounters;
+            SetupCategory();
+        }
+ 
+        private void SetupCategory()
+        {
+            if (!PerformanceCounterCategory.Exists(_stpCategoryName))
+            {
+                CounterCreationDataCollection counters = new CounterCreationDataCollection();
+
+                for (int i = 0; i < _stpPerformanceCounters.Length; i++)
+                {
+                    _stpPerformanceCounters[i].AddCounterToCollection(counters);
+                }
+
+
+                // *********** Remark for .NET 2.0 ***********
+                // If you are here, it means you got the warning that this overload
+                // of the method is deprecated in .NET 2.0. To use the correct 
+                // method overload, uncomment the third argument of the method.
+                PerformanceCounterCategory.Create(
+                    _stpCategoryName, 
+                    _stpCategoryHelp, 
+                    //PerformanceCounterCategoryType.MultiInstance,
+                    counters);
+                    
+            }
+        }
+ 
+        // Properties
+        public static STPPerformanceCounters Instance
+        {
+            get
+            {
+                return _instance;
+            }
+        }
+     }
+
+    internal class STPInstancePerformanceCounter : IDisposable
+    {
+        // Fields
+        private PerformanceCounter _pcs;
+
+        // Methods
+        protected STPInstancePerformanceCounter()
+        {
+        }
+
+        public STPInstancePerformanceCounter(
+            string instance, 
+            STPPerformanceCounterType spcType)
+        {
+            STPPerformanceCounters counters = STPPerformanceCounters.Instance;
+            _pcs = new PerformanceCounter(
+                STPPerformanceCounters._stpCategoryName, 
+                counters._stpPerformanceCounters[(int) spcType].Name, 
+                instance, 
+                false);
+            _pcs.RawValue = _pcs.RawValue;
+        }
+
+        ~STPInstancePerformanceCounter()
+        {
+            Close();
+        }
+
+        public void Close()
+        {
+            if (_pcs != null)
+            {
+                _pcs.RemoveInstance();
+                _pcs.Close();
+                _pcs = null;
+            }
+        }
+ 
+        public void Dispose()
+        {
+            Close();
+            GC.SuppressFinalize(this);
+        }
+ 
+        public virtual void Increment()
+        {
+            _pcs.Increment();
+        }
+ 
+        public virtual void IncrementBy(long val)
+        {
+            _pcs.IncrementBy(val);
+        }
+
+        public virtual void Set(long val)
+        {
+            _pcs.RawValue = val;
+        }
+    }
+
+    internal class STPInstanceNullPerformanceCounter : STPInstancePerformanceCounter
+    {
+        // Methods
+        public STPInstanceNullPerformanceCounter() {}
+        public override void Increment() {}
+        public override void IncrementBy(long value) {}
+        public override void Set(long val) {}
+    }
+        
+    internal interface ISTPInstancePerformanceCounters : IDisposable
+    {
+        void Close();
+        void SampleThreads(long activeThreads, long inUseThreads);
+        void SampleWorkItems(long workItemsQueued, long workItemsProcessed);
+        void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime);
+        void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime);
+    }
+
+
+    internal class STPInstancePerformanceCounters : ISTPInstancePerformanceCounters, IDisposable
+    {
+        // Fields
+        private STPInstancePerformanceCounter[] _pcs;
+        private static STPInstancePerformanceCounter _stpInstanceNullPerformanceCounter;
+
+        // Methods
+        static STPInstancePerformanceCounters()
+        {
+            _stpInstanceNullPerformanceCounter = new STPInstanceNullPerformanceCounter();
+        }
+ 
+        public STPInstancePerformanceCounters(string instance)
+        {
+            _pcs = new STPInstancePerformanceCounter[(int)STPPerformanceCounterType.LastCounter];
+            STPPerformanceCounters counters = STPPerformanceCounters.Instance;
+            for (int i = 0; i < _pcs.Length; i++)
+            {
+                if (instance != null)
+                {
+                    _pcs[i] = new STPInstancePerformanceCounter(
+                        instance, 
+                        (STPPerformanceCounterType) i);
+                }
+                else
+                {
+                    _pcs[i] = _stpInstanceNullPerformanceCounter;
+                }
+            }
+        }
+ 
+
+        public void Close()
+        {
+            if (null != _pcs)
+            {
+                for (int i = 0; i < _pcs.Length; i++)
+                {
+                    if (null != _pcs[i])
+                    {
+                        _pcs[i].Close();
+                    }
+                }
+                _pcs = null;
+            }
+        }
+
+        ~STPInstancePerformanceCounters()
+        {
+            Close();
+        }
+
+        public void Dispose()
+        {
+            Close();
+            GC.SuppressFinalize(this);
+        }
+ 
+        private STPInstancePerformanceCounter GetCounter(STPPerformanceCounterType spcType)
+        {
+            return _pcs[(int) spcType];
+        }
+
+        public void SampleThreads(long activeThreads, long inUseThreads)
+        {
+            GetCounter(STPPerformanceCounterType.ActiveThreads).Set(activeThreads);
+            GetCounter(STPPerformanceCounterType.InUseThreads).Set(inUseThreads);
+            GetCounter(STPPerformanceCounterType.OverheadThreads).Set(activeThreads-inUseThreads);
+
+            GetCounter(STPPerformanceCounterType.OverheadThreadsPercentBase).Set(activeThreads-inUseThreads);
+            GetCounter(STPPerformanceCounterType.OverheadThreadsPercent).Set(inUseThreads);
+        }
+
+        public void SampleWorkItems(long workItemsQueued, long workItemsProcessed)
+        {
+            GetCounter(STPPerformanceCounterType.WorkItems).Set(workItemsQueued+workItemsProcessed);
+            GetCounter(STPPerformanceCounterType.WorkItemsInQueue).Set(workItemsQueued);
+            GetCounter(STPPerformanceCounterType.WorkItemsProcessed).Set(workItemsProcessed);
+
+            GetCounter(STPPerformanceCounterType.WorkItemsQueuedPerSecond).Set(workItemsQueued);
+            GetCounter(STPPerformanceCounterType.WorkItemsProcessedPerSecond).Set(workItemsProcessed);
+        }
+
+        public void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime)
+        {
+            GetCounter(STPPerformanceCounterType.AvgWorkItemWaitTime).IncrementBy((long)workItemWaitTime.TotalMilliseconds);
+            GetCounter(STPPerformanceCounterType.AvgWorkItemWaitTimeBase).Increment();
+        }
+
+        public void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime)
+        {
+            GetCounter(STPPerformanceCounterType.AvgWorkItemProcessTime).IncrementBy((long)workItemProcessTime.TotalMilliseconds);
+            GetCounter(STPPerformanceCounterType.AvgWorkItemProcessTimeBase).Increment();
+        }
+    }
+
+    internal class NullSTPInstancePerformanceCounters : ISTPInstancePerformanceCounters, IDisposable
+    {
+        static NullSTPInstancePerformanceCounters()
+        {
+        }
+
+        private static NullSTPInstancePerformanceCounters _instance = new NullSTPInstancePerformanceCounters(null);
+
+        public static NullSTPInstancePerformanceCounters Instance
+        {
+            get { return _instance; }
+        }
+
+        public NullSTPInstancePerformanceCounters(string instance) {}
+         public void Close() {}
+        public void Dispose() {}
+ 
+        public void SampleThreads(long activeThreads, long inUseThreads) {}
+        public void SampleWorkItems(long workItemsQueued, long workItemsProcessed) {}
+        public void SampleWorkItemsWaitTime(TimeSpan workItemWaitTime) {}
+        public void SampleWorkItemsProcessTime(TimeSpan workItemProcessTime) {}
+    }
+
+}
diff --git a/ThirdParty/SmartThreadPool/STPStartInfo.cs b/ThirdParty/SmartThreadPool/STPStartInfo.cs
new file mode 100644
index 0000000..d181563
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/STPStartInfo.cs
@@ -0,0 +1,99 @@
+// Ami Bar
+// amibar@gmail.com
+
+using System.Threading;
+
+namespace Amib.Threading
+{
+    /// <summary>
+    /// Summary description for STPStartInfo.
+    /// </summary>
+    public class STPStartInfo : WIGStartInfo
+    {
+        /// <summary>
+        /// Idle timeout in milliseconds.
+        /// If a thread is idle for _idleTimeout milliseconds then 
+        /// it may quit.
+        /// </summary>
+        private int _idleTimeout;
+
+        /// <summary>
+        /// The lower limit of threads in the pool.
+        /// </summary>
+        private int _minWorkerThreads;
+
+        /// <summary>
+        /// The upper limit of threads in the pool.
+        /// </summary>
+        private int _maxWorkerThreads;
+
+        /// <summary>
+        /// The priority of the threads in the pool
+        /// </summary>
+        private ThreadPriority _threadPriority;
+
+        /// <summary>
+        /// If this field is not null then the performance counters are enabled
+        /// and use the string as the name of the instance.
+        /// </summary>
+        private string _pcInstanceName;
+
+        private int _stackSize;
+
+        public STPStartInfo() : base()
+        {
+            _idleTimeout = SmartThreadPool.DefaultIdleTimeout;
+            _minWorkerThreads = SmartThreadPool.DefaultMinWorkerThreads;
+            _maxWorkerThreads = SmartThreadPool.DefaultMaxWorkerThreads;
+            _threadPriority = SmartThreadPool.DefaultThreadPriority;
+            _pcInstanceName = SmartThreadPool.DefaultPerformanceCounterInstanceName;
+            _stackSize = SmartThreadPool.DefaultStackSize;
+        }
+
+        public STPStartInfo(STPStartInfo stpStartInfo) : base(stpStartInfo)
+        {
+            _idleTimeout = stpStartInfo._idleTimeout;
+            _minWorkerThreads = stpStartInfo._minWorkerThreads;
+            _maxWorkerThreads = stpStartInfo._maxWorkerThreads;
+            _threadPriority = stpStartInfo._threadPriority;
+            _pcInstanceName = stpStartInfo._pcInstanceName;
+            _stackSize = stpStartInfo._stackSize;
+        }
+
+        public int IdleTimeout
+        {
+            get { return _idleTimeout; }
+            set { _idleTimeout = value; }
+        }
+
+        public int MinWorkerThreads
+        {
+            get { return _minWorkerThreads; }
+            set { _minWorkerThreads = value; }
+        }
+
+        public int MaxWorkerThreads
+        {
+            get { return _maxWorkerThreads; }
+            set { _maxWorkerThreads = value; }
+        }
+
+        public ThreadPriority ThreadPriority
+        {
+            get { return _threadPriority; }
+            set { _threadPriority = value; }
+        }
+
+        public string PerformanceCounterInstanceName
+        {
+            get { return _pcInstanceName; }
+            set { _pcInstanceName = value; }
+        }
+
+        public int StackSize
+        {
+            get { return _stackSize; }
+            set { _stackSize = value; }
+        }
+    }
+}
diff --git a/ThirdParty/SmartThreadPool/SmartThreadPool.cs b/ThirdParty/SmartThreadPool/SmartThreadPool.cs
new file mode 100644
index 0000000..c21984e
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/SmartThreadPool.cs
@@ -0,0 +1,1438 @@
+// Ami Bar
+// amibar@gmail.com
+//
+// Smart thread pool in C#.
+// 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.
+// 26 Dec 2004 - Changes:
+//        - 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. 
+//        The SmartThreadPool.WaitAny() is still limited by the .NET Framework.
+//        - 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
+// 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. 
+//
+// 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
+//
+// 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.
+
+using System;
+using System.Security;
+using System.Threading;
+using System.Collections;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+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)
+        /// </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
+        /// </summary>
+        public const CallToPostExecute DefaultCallToPostExecute = CallToPostExecute.Always;
+
+        /// <summary>
+        /// The default post execute method to run. 
+        /// When null it means not to call it.
+        /// </summary>
+        public static readonly PostExecuteWorkItemCallback DefaultPostExecuteWorkItemCallback = null;
+
+        /// <summary>
+        /// The default work item priority
+        /// </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.
+        /// </summary>
+        public const bool DefaultStartSuspended = false;
+
+        /// <summary>
+        /// The default is not to use the performance counters
+        /// </summary>
+        public static readonly string DefaultPerformanceCounterInstanceName = null;
+
+        public static readonly int DefaultStackSize = 0;
+
+        /// <summary>
+        /// The default thread priority
+        /// </summary>
+        public const ThreadPriority DefaultThreadPriority = ThreadPriority.Normal;
+
+        #endregion
+
+        #region Member Variables
+
+        /// <summary>
+        /// Contains the name of this instance of SmartThreadPool.
+        /// Can be changed by the user.
+        /// </summary>
+        private string _name = "SmartThreadPool";
+
+        /// <summary>
+        /// Hashtable of all the threads in the thread pool.
+        /// </summary>
+        private Hashtable _workerThreads = Hashtable.Synchronized(new Hashtable());
+
+        /// <summary>
+        /// Queue of work items.
+        /// </summary>
+        private WorkItemsQueue _workItemsQueue = new WorkItemsQueue();
+
+        /// <summary>
+        /// Count the work items handled.
+        /// Used by the performance counter.
+        /// </summary>
+        private long _workItemsProcessed = 0;
+
+        /// <summary>
+        /// Number of threads that currently work (not idle).
+        /// </summary>
+        private int _inUseWorkerThreads = 0;
+
+        /// <summary>
+        /// Start information to use. 
+        /// It is simpler than providing many constructors.
+        /// </summary>
+        private STPStartInfo _stpStartInfo = new STPStartInfo();
+
+        /// <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 = 0;
+
+        /// <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);
+
+        /// <summary>
+        /// An event to signal all the threads to quit immediately.
+        /// </summary>
+        private ManualResetEvent _shuttingDownEvent = new ManualResetEvent(false);
+
+        /// <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;
+
+        /// <summary>
+        /// Indicate that the SmartThreadPool has been disposed
+        /// </summary>
+        private bool _isDisposed = false;
+
+        /// <summary>
+        /// Event to send that the thread pool is idle
+        /// </summary>
+        private event EventHandler _stpIdle;
+
+        /// <summary>
+        /// On idle event
+        /// </summary>
+        //private event WorkItemsGroupIdleHandler _onIdle;
+
+        /// <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());
+
+        /// <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;
+
+        /// <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;
+
+        #endregion
+
+        #region Construction and Finalization
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public SmartThreadPool()
+        {
+            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>
+        /// <param name="maxWorkerThreads">Upper limit of threads in the pool</param>
+        public SmartThreadPool(
+            int idleTimeout,
+            int maxWorkerThreads)
+        {
+            _stpStartInfo.IdleTimeout = idleTimeout;
+            _stpStartInfo.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.IdleTimeout = idleTimeout;
+            _stpStartInfo.MaxWorkerThreads = maxWorkerThreads;
+            _stpStartInfo.MinWorkerThreads = minWorkerThreads;
+            Initialize();
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public SmartThreadPool(STPStartInfo stpStartInfo)
+        {
+            _stpStartInfo = new STPStartInfo(stpStartInfo);
+            Initialize();
+        }
+
+        private void Initialize()
+        {
+            ValidateSTPStartInfo();
+
+            if (null != _stpStartInfo.PerformanceCounterInstanceName)
+            {
+                try
+                {
+                    _pcs = new STPInstancePerformanceCounters(_stpStartInfo.PerformanceCounterInstanceName);
+                }
+                catch(Exception e)
+                {
+                    Debug.WriteLine("Unable to create Performance Counters: " + e.ToString());
+                    _pcs = NullSTPInstancePerformanceCounters.Instance;
+                }
+            }
+
+            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)
+            {
+                throw new ArgumentOutOfRangeException(
+                    "MaxWorkerThreads", "MaxWorkerThreads must be greater than zero");
+            }
+
+            if (_stpStartInfo.MinWorkerThreads > _stpStartInfo.MaxWorkerThreads)
+            {
+                throw new ArgumentOutOfRangeException(
+                    "MinWorkerThreads, maxWorkerThreads", 
+                    "MaxWorkerThreads must be greater or equal to MinWorkerThreads");
+            }
+        }
+
+        private 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");
+                _isIdleWaitHandle.Reset();
+            }
+        }
+
+        private void DecrementWorkItemsCount()
+        {
+            ++_workItemsProcessed;
+
+            // The counter counts even if the work item was cancelled
+            _pcs.SampleWorkItems(_workItemsQueue.Count, _workItemsProcessed);
+
+            int count = Interlocked.Decrement(ref _currentWorkItemsCount);
+            //Trace.WriteLine("WorkItemsCount = " + _currentWorkItemsCount.ToString());
+            if (count == 0) 
+            {
+                //Trace.WriteLine("STP is idle");
+                _isIdleWaitHandle.Set();
+            }
+        }
+
+        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 hashtable
+            if (_workerThreads.Contains(Thread.CurrentThread))
+            {
+                _workerThreads.Remove(Thread.CurrentThread);
+                _pcs.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 (_stpStartInfo.StartSuspended)
+            {
+                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;
+                    }
+
+                    // Create a new thread
+                    Thread workerThread = new Thread(new ThreadStart(ProcessQueuedItems), _stpStartInfo.StackSize);
+
+                    // Configure the new thread and start it
+                    workerThread.Name = "STP " + Name + " Thread #" + _threadCounter;
+                    workerThread.IsBackground = true;
+                    workerThread.Priority = _stpStartInfo.ThreadPriority;
+                    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)
+                {
+                    // Update the last time this thread was seen alive.
+                    // It's good for debugging.
+                    _workerThreads[Thread.CurrentThread] = DateTime.Now;
+
+                    // Wait for a work item, shutdown, or timeout
+                    WorkItem workItem = Dequeue();
+
+                    // Update the last time this thread was seen alive.
+                    // It's good for debugging.
+                    _workerThreads[Thread.CurrentThread] = DateTime.Now;
+
+                    // 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;
+
+                        // 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);
+                        _pcs.SampleThreads(_workerThreads.Count, inUseWorkerThreads);
+
+                        // 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)
+                    {
+                        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)
+            {
+                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;
+            }
+            finally
+            {
+                _pcs.SampleWorkItemsProcessTime(workItem.ProcessTime);
+            }
+        }
+
+
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Queue a work item
+        /// </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();
+        }
+
+        /// <summary>
+        /// Queue a work item
+        /// </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();
+        }
+
+        /// <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();
+        }
+
+        /// <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)
+        {
+            ValidateNotDisposed();
+            ValidateCallback(callback);
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, callback, state);
+            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="workItemPriority">The work item priority</param>
+        /// <returns>Returns a work item result</returns>
+        public IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state, WorkItemPriority workItemPriority)
+        {
+            ValidateNotDisposed();
+            ValidateCallback(callback);
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, callback, state, workItemPriority);
+            Enqueue(workItem);
+            return workItem.GetWorkItemResult();
+        }
+
+        /// <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();
+        }
+
+        /// <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>
+        /// <returns>Returns a work item result</returns>
+        public IWorkItemResult QueueWorkItem(
+            WorkItemCallback callback, 
+            object state,
+            PostExecuteWorkItemCallback postExecuteWorkItemCallback)
+        {
+            ValidateNotDisposed();
+            ValidateCallback(callback);
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, callback, state, postExecuteWorkItemCallback);
+            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="workItemPriority">The work item priority</param>
+        /// <returns>Returns a work item result</returns>
+        public IWorkItemResult QueueWorkItem(
+            WorkItemCallback callback, 
+            object state,
+            PostExecuteWorkItemCallback postExecuteWorkItemCallback,
+            WorkItemPriority workItemPriority)
+        {
+            ValidateNotDisposed();
+            ValidateCallback(callback);
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, callback, state, postExecuteWorkItemCallback, workItemPriority);
+            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>
+        /// <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)
+        {
+            ValidateNotDisposed();
+            ValidateCallback(callback);
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _stpStartInfo, callback, state, postExecuteWorkItemCallback, callToPostExecute, workItemPriority);
+            Enqueue(workItem);
+            return workItem.GetWorkItemResult();
+        }
+
+        /// <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);
+        }
+
+        /// <summary>
+        /// Wait for the thread pool to be idle
+        /// </summary>
+        public bool WaitForIdle(int millisecondsTimeout)
+        {
+            ValidateWaitForIdle();
+            return _isIdleWaitHandle.WaitOne(millisecondsTimeout, false);
+        }
+
+        private void ValidateWaitForIdle()
+        {
+            if(_smartThreadPool == this)
+            {
+                throw new NotSupportedException(
+                    "WaitForIdle cannot be called from a thread on its SmartThreadPool, it will cause may cause a deadlock");
+            }
+        }
+
+        internal void ValidateWorkItemsGroupWaitForIdle(IWorkItemsGroup workItemsGroup)
+        {
+            ValidateWorkItemsGroupWaitForIdleImpl(workItemsGroup, SmartThreadPool._currentWorkItem);
+            if ((null != workItemsGroup) && 
+                (null != SmartThreadPool._currentWorkItem) &&
+                SmartThreadPool._currentWorkItem.WasQueuedBy(workItemsGroup))
+            {
+                throw new NotSupportedException("WaitForIdle cannot be called from a thread on its SmartThreadPool, it will cause may cause a deadlock");
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private 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 will cause may cause a deadlock");
+            }
+        }
+
+
+
+        /// <summary>
+        /// Force the SmartThreadPool to shutdown
+        /// </summary>
+        public void Shutdown()
+        {
+            Shutdown(true, 0);
+        }
+
+        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 = _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();
+
+                // Make a copy of the threads' references in the pool
+                threads = new Thread [_workerThreads.Count];
+                _workerThreads.Keys.CopyTo(threads, 0);
+            }
+
+            int millisecondsLeft = millisecondsTimeout;
+            DateTime start = DateTime.Now;
+            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.Now - start;
+                    millisecondsLeft = millisecondsTimeout - (int)ts.TotalMilliseconds;
+                }
+            }
+
+            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.
+                        }
+                    }
+                }
+            }
+
+            // 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)
+        {
+            return WaitAll(workItemResults, Timeout.Infinite, true);
+        }
+
+        /// <summary>
+        /// Wait for all work items to complete
+        /// </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);
+        }
+
+        /// <summary>
+        /// Wait for all work items to complete
+        /// </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)
+        {
+            return WaitAll(workItemResults, (int)timeout.TotalMilliseconds, exitContext, cancelWaitHandle);
+        }
+
+        /// <summary>
+        /// Wait for all work items to complete
+        /// </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)
+        {
+            return WorkItem.WaitAll(workItemResults, millisecondsTimeout, exitContext, null);
+        }
+
+        /// <summary>
+        /// Wait for all work items to complete
+        /// </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)
+        {
+            return WorkItem.WaitAll(workItemResults, millisecondsTimeout, exitContext, cancelWaitHandle);
+        }
+
+
+        /// <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);
+        }
+
+        /// <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>
+        /// <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)
+        {
+            return WaitAny(workItemResults, (int)timeout.TotalMilliseconds, exitContext);
+        }
+
+        /// <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);
+        }
+
+        /// <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="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)
+        {
+            return WorkItem.WaitAny(workItemResults, millisecondsTimeout, exitContext, null);
+        }
+
+        /// <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="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
+        {
+            add
+            {
+                throw new NotImplementedException("This event is not implemented in the SmartThreadPool class. Please create a WorkItemsGroup in order to use this feature.");
+                //_onIdle += value;
+            }
+            remove
+            {
+                throw new NotImplementedException("This event is not implemented in the SmartThreadPool class. Please create a WorkItemsGroup in order to use this feature.");
+                //_onIdle -= value;
+            }
+        }
+
+        public void Cancel()
+        {
+            ICollection workItemsGroups = _workItemsGroups.Values;
+            foreach(WorkItemsGroup workItemsGroup in workItemsGroups)
+            {
+                workItemsGroup.Cancel();
+            }
+        }
+
+        public void Start()
+        {
+            lock (this)
+            {
+                if (!this._stpStartInfo.StartSuspended)
+                {
+                    return;
+                }
+                _stpStartInfo.StartSuspended = false;
+            }
+            
+            ICollection workItemsGroups = _workItemsGroups.Values;
+            foreach(WorkItemsGroup workItemsGroup in workItemsGroups)
+            {
+                workItemsGroup.OnSTPIsStarting();
+            }
+
+            StartOptimalNumberOfThreads();
+        }
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Get/Set the name of the SmartThreadPool instance
+        /// </summary>
+        public string Name 
+        { 
+            get
+            {
+                return _name;
+            }
+
+            set
+            {
+                _name = value;
+            }
+        }
+
+        /// <summary>
+        /// Get the lower limit of threads in the pool.
+        /// </summary>
+        public int MinThreads 
+        { 
+            get 
+            {
+                ValidateNotDisposed();
+                return _stpStartInfo.MinWorkerThreads; 
+            }
+        }
+
+        /// <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.
+        /// </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>
+        /// Get the number of work items in the queue.
+        /// </summary>
+        public int WaitingCallbacks 
+        { 
+            get 
+            { 
+                ValidateNotDisposed();
+                return _workItemsQueue.Count;
+            } 
+        }
+
+
+        public event EventHandler Idle
+        {
+            add
+            {
+                _stpIdle += value;
+            }
+
+            remove
+            {
+                _stpIdle -= value;
+            }
+        }
+
+        #endregion
+
+        #region IDisposable Members
+
+//        ~SmartThreadPool()
+//        {
+//            Dispose();
+//        }
+
+        public void Dispose()
+        {
+            if (!_isDisposed)
+            {
+                if (!_shutdown)
+                {
+                    Shutdown();
+                }
+
+                if (null != _shuttingDownEvent)
+                {
+                    _shuttingDownEvent.Close();
+                    _shuttingDownEvent = null;
+                }
+                _workerThreads.Clear();
+                _isDisposed = true;
+                GC.SuppressFinalize(this);
+            }
+        }
+
+        private void ValidateNotDisposed()
+        {
+            if(_isDisposed)
+            {
+                throw new ObjectDisposedException(GetType().ToString(), "The SmartThreadPool has been shutdown");
+            }
+        }
+        #endregion
+    }
+    #endregion
+}
diff --git a/ThirdParty/SmartThreadPool/WIGStartInfo.cs b/ThirdParty/SmartThreadPool/WIGStartInfo.cs
new file mode 100644
index 0000000..150317f
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/WIGStartInfo.cs
@@ -0,0 +1,99 @@
+// Ami Bar
+// amibar@gmail.com
+
+namespace Amib.Threading
+{
+    /// <summary>
+    /// Summary description for WIGStartInfo.
+    /// </summary>
+    public class WIGStartInfo
+    {
+        /// <summary>
+        /// Use the caller's security context
+        /// </summary>
+        private bool _useCallerCallContext;
+
+        /// <summary>
+        /// Use the caller's HTTP context
+        /// </summary>
+        private bool _useCallerHttpContext;
+
+        /// <summary>
+        /// Dispose of the state object of a work item
+        /// </summary>
+        private bool _disposeOfStateObjects;
+
+        /// <summary>
+        /// The option to run the post execute
+        /// </summary>
+        private CallToPostExecute _callToPostExecute;
+
+        /// <summary>
+        /// A post execute callback to call when none is provided in 
+        /// the QueueWorkItem method.
+        /// </summary>
+        private PostExecuteWorkItemCallback _postExecuteWorkItemCallback;
+
+        /// <summary>
+        /// Indicate the WorkItemsGroup to suspend the handling of the work items
+        /// until the Start() method is called.
+        /// </summary>
+        private bool _startSuspended;
+
+        public WIGStartInfo()
+        {
+            _useCallerCallContext = SmartThreadPool.DefaultUseCallerCallContext;
+            _useCallerHttpContext = SmartThreadPool.DefaultUseCallerHttpContext;
+            _disposeOfStateObjects = SmartThreadPool.DefaultDisposeOfStateObjects;
+            _callToPostExecute = SmartThreadPool.DefaultCallToPostExecute;
+            _postExecuteWorkItemCallback = SmartThreadPool.DefaultPostExecuteWorkItemCallback;
+            _startSuspended = SmartThreadPool.DefaultStartSuspended;
+        }
+
+        public WIGStartInfo(WIGStartInfo wigStartInfo)
+        {
+            _useCallerCallContext = wigStartInfo._useCallerCallContext;
+            _useCallerHttpContext = wigStartInfo._useCallerHttpContext;
+            _disposeOfStateObjects = wigStartInfo._disposeOfStateObjects;
+            _callToPostExecute = wigStartInfo._callToPostExecute;
+            _postExecuteWorkItemCallback = wigStartInfo._postExecuteWorkItemCallback;
+            _startSuspended = wigStartInfo._startSuspended;
+        }
+
+        public bool UseCallerCallContext
+        {
+            get { return _useCallerCallContext; }
+            set { _useCallerCallContext = value; }
+        }
+
+        public bool UseCallerHttpContext
+        {
+            get { return _useCallerHttpContext; }
+            set { _useCallerHttpContext = value; }
+        }
+
+        public bool DisposeOfStateObjects
+        {
+            get { return _disposeOfStateObjects; }
+            set { _disposeOfStateObjects = value; }
+        }
+
+        public CallToPostExecute CallToPostExecute
+        {
+            get { return _callToPostExecute; }
+            set { _callToPostExecute = value; }
+        }
+
+        public PostExecuteWorkItemCallback PostExecuteWorkItemCallback
+        {
+            get { return _postExecuteWorkItemCallback; }
+            set { _postExecuteWorkItemCallback = value; }
+        }
+
+        public bool StartSuspended
+        {
+            get { return _startSuspended; }
+            set { _startSuspended = value; }
+        }
+    }
+}
diff --git a/ThirdParty/SmartThreadPool/WorkItem.cs b/ThirdParty/SmartThreadPool/WorkItem.cs
new file mode 100644
index 0000000..d0c0524
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/WorkItem.cs
@@ -0,0 +1,1035 @@
+// Ami Bar
+// amibar@gmail.com
+
+using System;
+using System.Threading;
+using System.Diagnostics;
+
+namespace Amib.Threading.Internal
+{
+    #region WorkItem Delegate
+
+    /// <summary>
+    /// An internal delegate to call when the WorkItem starts or completes
+    /// </summary>
+    internal delegate void WorkItemStateCallback(WorkItem workItem);
+
+    #endregion
+
+    #region IInternalWorkItemResult interface 
+
+    public class CanceledWorkItemsGroup
+    {
+        public readonly static CanceledWorkItemsGroup NotCanceledWorkItemsGroup = new CanceledWorkItemsGroup();
+
+        private bool _isCanceled = false;
+        public bool IsCanceled 
+        { 
+            get { return _isCanceled; }
+            set { _isCanceled = value; }
+        }
+    }
+
+    internal interface IInternalWorkItemResult
+    {
+        event WorkItemStateCallback OnWorkItemStarted;
+        event WorkItemStateCallback OnWorkItemCompleted;
+    }
+
+    #endregion
+
+    #region IWorkItem interface
+
+    public interface IWorkItem
+    {
+
+    }
+
+    #endregion
+
+    #region WorkItem class
+
+    /// <summary>
+    /// Holds a callback delegate and the state for that delegate.
+    /// </summary>
+    public class WorkItem : IHasWorkItemPriority, IWorkItem
+    {
+        #region WorkItemState enum
+
+        /// <summary>
+        /// Indicates the state of the work item in the thread pool
+        /// </summary>
+        private enum WorkItemState
+        {
+            InQueue,
+            InProgress,
+            Completed,
+            Canceled,
+        }
+
+        #endregion
+
+        #region Member Variables
+
+        public Thread currentThread;
+
+        /// <summary>
+        /// Callback delegate for the callback.
+        /// </summary>
+        private WorkItemCallback _callback;
+
+        /// <summary>
+        /// State with which to call the callback delegate.
+        /// </summary>
+        private object _state;
+
+        /// <summary>
+        /// Stores the caller's context
+        /// </summary>
+        private CallerThreadContext _callerContext;
+
+        /// <summary>
+        /// Holds the result of the mehtod
+        /// </summary>
+        private object _result;
+
+        /// <summary>
+        /// Hold the exception if the method threw it
+        /// </summary>
+        private Exception _exception;
+
+        /// <summary>
+        /// Hold the state of the work item
+        /// </summary>
+        private WorkItemState _workItemState;
+
+        /// <summary>
+        /// A ManualResetEvent to indicate that the result is ready
+        /// </summary>
+        private ManualResetEvent _workItemCompleted;
+
+        /// <summary>
+        /// A reference count to the _workItemCompleted. 
+        /// When it reaches to zero _workItemCompleted is Closed
+        /// </summary>
+        private int _workItemCompletedRefCount;
+
+        /// <summary>
+        /// Represents the result state of the work item
+        /// </summary>
+        private WorkItemResult _workItemResult;
+
+        /// <summary>
+        /// Work item info
+        /// </summary>
+        private WorkItemInfo _workItemInfo;
+
+        /// <summary>
+        /// Called when the WorkItem starts
+        /// </summary>
+        private event WorkItemStateCallback _workItemStartedEvent;
+
+        /// <summary>
+        /// Called when the WorkItem completes
+        /// </summary>
+        private event WorkItemStateCallback _workItemCompletedEvent;
+
+        /// <summary>
+        /// A reference to an object that indicates whatever the 
+        /// WorkItemsGroup has been canceled
+        /// </summary>
+        private CanceledWorkItemsGroup _canceledWorkItemsGroup = CanceledWorkItemsGroup.NotCanceledWorkItemsGroup;
+
+        /// <summary>
+        /// The work item group this work item belong to.
+        /// 
+        /// </summary>
+        private IWorkItemsGroup _workItemsGroup;
+
+        #region Performance Counter fields
+
+        /// <summary>
+        /// The time when the work items is queued.
+        /// Used with the performance counter.
+        /// </summary>
+        private DateTime _queuedTime;
+
+        /// <summary>
+        /// The time when the work items starts its execution.
+        /// Used with the performance counter.
+        /// </summary>
+        private DateTime _beginProcessTime;
+
+        /// <summary>
+        /// The time when the work items ends its execution.
+        /// Used with the performance counter.
+        /// </summary>
+        private DateTime _endProcessTime;
+
+        #endregion
+
+        #endregion
+
+        #region Properties
+
+        public TimeSpan WaitingTime
+        {
+            get 
+            {
+                return (_beginProcessTime - _queuedTime);
+            }
+        }
+
+        public TimeSpan ProcessTime
+        {
+            get 
+            {
+                return (_endProcessTime - _beginProcessTime);
+            }
+        }
+
+        #endregion
+
+        #region Construction
+
+        /// <summary>
+        /// Initialize the callback holding object.
+        /// </summary>
+        /// <param name="callback">Callback delegate for the callback.</param>
+        /// <param name="state">State with which to call the callback delegate.</param>
+        /// 
+        /// We assume that the WorkItem object is created within the thread
+        /// that meant to run the callback
+        public WorkItem(
+            IWorkItemsGroup workItemsGroup,
+            WorkItemInfo workItemInfo,
+            WorkItemCallback callback, 
+            object state)
+        {
+            _workItemsGroup = workItemsGroup;
+            _workItemInfo = workItemInfo;
+
+            if (_workItemInfo.UseCallerCallContext || _workItemInfo.UseCallerHttpContext)
+            {
+                _callerContext = CallerThreadContext.Capture(_workItemInfo.UseCallerCallContext, _workItemInfo.UseCallerHttpContext);
+            }
+
+            _callback = callback;
+            _state = state;
+            _workItemResult = new WorkItemResult(this);
+            Initialize();
+        }
+
+        internal void Initialize()
+        {
+            _workItemState = WorkItemState.InQueue;
+            _workItemCompleted = null;
+            _workItemCompletedRefCount = 0;
+        }
+
+        internal bool WasQueuedBy(IWorkItemsGroup workItemsGroup)
+        {
+            return (workItemsGroup == _workItemsGroup);
+        }
+
+
+        #endregion
+
+        #region Methods
+
+        public CanceledWorkItemsGroup CanceledWorkItemsGroup
+        {
+            get
+            {
+                return _canceledWorkItemsGroup;
+            }
+
+            set
+            {
+                _canceledWorkItemsGroup = value;
+            }
+        }
+
+        /// <summary>
+        /// Change the state of the work item to in progress if it wasn't canceled.
+        /// </summary>
+        /// <returns>
+        /// Return true on success or false in case the work item was canceled.
+        /// If the work item needs to run a post execute then the method will return true.
+        /// </returns>
+        public bool StartingWorkItem()
+        {
+            _beginProcessTime = DateTime.Now;
+
+            lock(this)
+            {
+                if (IsCanceled)
+                {
+                    bool result = false;
+                    if ((_workItemInfo.PostExecuteWorkItemCallback != null) &&
+                        ((_workItemInfo.CallToPostExecute & CallToPostExecute.WhenWorkItemCanceled) == CallToPostExecute.WhenWorkItemCanceled))
+                    {
+                        result = true;
+                    }
+
+                    return result;
+                }
+
+                Debug.Assert(WorkItemState.InQueue == GetWorkItemState());
+
+                SetWorkItemState(WorkItemState.InProgress);
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Execute the work item and the post execute
+        /// </summary>
+        public void Execute()
+        {
+            CallToPostExecute currentCallToPostExecute = 0;
+
+            // Execute the work item if we are in the correct state
+            switch(GetWorkItemState())
+            {
+                case WorkItemState.InProgress:
+                    currentCallToPostExecute |= CallToPostExecute.WhenWorkItemNotCanceled;
+                    ExecuteWorkItem();
+                    break;
+                case WorkItemState.Canceled:
+                    currentCallToPostExecute |= CallToPostExecute.WhenWorkItemCanceled;
+                    break;
+                default:
+                    Debug.Assert(false);
+                    throw new NotSupportedException();
+            }
+
+            // Run the post execute as needed
+            if ((currentCallToPostExecute & _workItemInfo.CallToPostExecute) != 0)
+            {
+                PostExecute();
+            }
+
+            _endProcessTime = DateTime.Now;
+        }
+
+        internal void FireWorkItemCompleted()
+        {
+            try
+            {
+                if (null != _workItemCompletedEvent)
+                {
+                    _workItemCompletedEvent(this);
+                }
+            }
+            catch // Ignore exceptions
+            {}
+        }
+
+        /// <summary>
+        /// Execute the work item
+        /// </summary>
+        private void ExecuteWorkItem()
+        {
+            CallerThreadContext ctc = null;
+            if (null != _callerContext)
+            {
+                ctc = CallerThreadContext.Capture(_callerContext.CapturedCallContext, _callerContext.CapturedHttpContext);
+                CallerThreadContext.Apply(_callerContext);
+            }
+
+            Exception exception = null;
+            object result = null;
+
+            try
+            {
+                result = _callback(_state);
+            }
+            catch (Exception e) 
+            {
+                // Save the exception so we can rethrow it later
+                exception = e;
+            }
+        
+            if (null != _callerContext)
+            {
+                CallerThreadContext.Apply(ctc);
+            }
+
+            SetResult(result, exception);
+        }
+
+        /// <summary>
+        /// Runs the post execute callback
+        /// </summary>
+        private void PostExecute()
+        {
+            if (null != _workItemInfo.PostExecuteWorkItemCallback)
+            {
+                try
+                {
+                    _workItemInfo.PostExecuteWorkItemCallback(this._workItemResult);
+                }
+                catch (Exception e) 
+                {
+                    Debug.Assert(null != e);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Set the result of the work item to return
+        /// </summary>
+        /// <param name="result">The result of the work item</param>
+        internal void SetResult(object result, Exception exception)
+        {
+            _result = result;
+            _exception = exception;
+            SignalComplete(false);
+        }
+
+        /// <summary>
+        /// Returns the work item result
+        /// </summary>
+        /// <returns>The work item result</returns>
+        internal IWorkItemResult GetWorkItemResult()
+        {
+            return _workItemResult;
+        }
+
+        /// <summary>
+        /// Wait for all work items to complete
+        /// </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>
+        internal static bool WaitAll(
+            IWorkItemResult [] workItemResults,
+            int millisecondsTimeout,
+            bool exitContext,
+            WaitHandle cancelWaitHandle)
+        {
+            if (0 == workItemResults.Length)
+            {
+                return true;
+            }
+
+            bool success;
+            WaitHandle [] waitHandles = new WaitHandle[workItemResults.Length];;
+            GetWaitHandles(workItemResults, waitHandles);
+
+            if ((null == cancelWaitHandle) && (waitHandles.Length <= 64))
+            {
+                success = WaitHandle.WaitAll(waitHandles, millisecondsTimeout, exitContext);
+            }
+            else
+            {
+                success = true;
+                int millisecondsLeft = millisecondsTimeout;
+                DateTime start = DateTime.Now;
+
+                WaitHandle [] whs;
+                if (null != cancelWaitHandle)
+                {
+                    whs = new WaitHandle [] { null, cancelWaitHandle };
+                }
+                else
+                {
+                    whs = new WaitHandle [] { null };
+                }
+
+                bool waitInfinitely = (Timeout.Infinite == millisecondsTimeout);
+                // Iterate over the wait handles and wait for each one to complete.
+                // We cannot use WaitHandle.WaitAll directly, because the cancelWaitHandle
+                // won't affect it.
+                // Each iteration we update the time left for the timeout.
+                for(int i = 0; i < workItemResults.Length; ++i)
+                {
+                    // WaitAny don't work with negative numbers
+                    if (!waitInfinitely && (millisecondsLeft < 0))
+                    {
+                        success = false;
+                        break;
+                    }
+
+                    whs[0] = waitHandles[i];
+                    int result = WaitHandle.WaitAny(whs, millisecondsLeft, exitContext);
+                    if((result > 0) || (WaitHandle.WaitTimeout == result))
+                    {
+                        success = false;
+                        break;
+                    }
+
+                    if(!waitInfinitely)
+                    {
+                        // Update the time left to wait
+                        TimeSpan ts = DateTime.Now - start;
+                        millisecondsLeft = millisecondsTimeout - (int)ts.TotalMilliseconds;
+                    }
+                }
+            }
+            // Release the wait handles
+            ReleaseWaitHandles(workItemResults);
+
+            return success;
+        }
+
+        /// <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="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>
+        internal static int WaitAny(            
+            IWorkItemResult [] workItemResults,
+            int millisecondsTimeout,
+            bool exitContext,
+            WaitHandle cancelWaitHandle)
+        {
+            WaitHandle [] waitHandles = null;
+
+            if (null != cancelWaitHandle)
+            {
+                waitHandles = new WaitHandle[workItemResults.Length+1];
+                GetWaitHandles(workItemResults, waitHandles);
+                waitHandles[workItemResults.Length] = cancelWaitHandle;
+            }
+            else
+            {
+                waitHandles = new WaitHandle[workItemResults.Length];
+                GetWaitHandles(workItemResults, waitHandles);
+            }
+
+            int result = WaitHandle.WaitAny(waitHandles, millisecondsTimeout, exitContext);
+
+            // Treat cancel as timeout
+            if (null != cancelWaitHandle)
+            {
+                if (result == workItemResults.Length)
+                {
+                    result = WaitHandle.WaitTimeout;
+                }
+            }
+
+            ReleaseWaitHandles(workItemResults);
+
+            return result;
+        }
+
+        /// <summary>
+        /// Fill an array of wait handles with the work items wait handles.
+        /// </summary>
+        /// <param name="workItemResults">An array of work item results</param>
+        /// <param name="waitHandles">An array of wait handles to fill</param>
+        private static void GetWaitHandles(
+            IWorkItemResult [] workItemResults,
+            WaitHandle [] waitHandles)
+        {
+            for(int i = 0; i < workItemResults.Length; ++i)
+            {
+                WorkItemResult wir = workItemResults[i] as WorkItemResult;
+                Debug.Assert(null != wir, "All workItemResults must be WorkItemResult objects");
+
+                waitHandles[i] = wir.GetWorkItem().GetWaitHandle();
+            }
+        }
+
+        /// <summary>
+        /// Release the work items' wait handles
+        /// </summary>
+        /// <param name="workItemResults">An array of work item results</param>
+        private static void ReleaseWaitHandles(IWorkItemResult [] workItemResults)
+        {
+            for(int i = 0; i < workItemResults.Length; ++i)
+            {
+                WorkItemResult wir = workItemResults[i] as WorkItemResult;
+
+                wir.GetWorkItem().ReleaseWaitHandle();
+            }
+        }
+
+
+        #endregion
+        
+        #region Private Members
+
+        private WorkItemState GetWorkItemState()
+        {
+            if (_canceledWorkItemsGroup.IsCanceled)
+            {
+                return WorkItemState.Canceled;
+            }
+            return _workItemState;
+
+        }
+        /// <summary>
+        /// Sets the work item's state
+        /// </summary>
+        /// <param name="workItemState">The state to set the work item to</param>
+        private void SetWorkItemState(WorkItemState workItemState)
+        {
+            lock(this)
+            {
+                _workItemState = workItemState;
+            }
+        }
+
+        /// <summary>
+        /// Signals that work item has been completed or canceled
+        /// </summary>
+        /// <param name="canceled">Indicates that the work item has been canceled</param>
+        private void SignalComplete(bool canceled)
+        {
+            SetWorkItemState(canceled ? WorkItemState.Canceled : WorkItemState.Completed);
+            lock(this)
+            {
+                // If someone is waiting then signal.
+                if (null != _workItemCompleted)
+                {
+                    _workItemCompleted.Set();
+                }
+            }
+        }
+
+        internal void WorkItemIsQueued()
+        {
+            _queuedTime = DateTime.Now;
+        }
+
+        #endregion
+        
+        #region Members exposed by WorkItemResult
+
+        /// <summary>
+        /// Cancel the work item if it didn't start running yet.
+        /// </summary>
+        /// <returns>Returns true on success or false if the work item is in progress or already completed</returns>
+        private bool Cancel()
+        {
+            lock(this)
+            {
+                switch(GetWorkItemState())
+                {
+                    case WorkItemState.Canceled:
+                        //Debug.WriteLine("Work item already canceled");
+                        return true;
+                    case WorkItemState.Completed:
+                    case WorkItemState.InProgress:
+                        //Debug.WriteLine("Work item cannot be canceled");
+                        return false;
+                    case WorkItemState.InQueue:
+                        // Signal to the wait for completion that the work
+                        // item has been completed (canceled). There is no
+                        // reason to wait for it to get out of the queue
+                        SignalComplete(true);
+                        //Debug.WriteLine("Work item canceled");
+                        return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Get the result of the work item.
+        /// If the work item didn't run yet then the caller waits for the result, timeout, or cancel.
+        /// In case of error the method throws and exception
+        /// </summary>
+        /// <returns>The result of the work item</returns>
+        private object GetResult(
+            int millisecondsTimeout,
+            bool exitContext,
+            WaitHandle cancelWaitHandle)
+        {
+            Exception e = null;
+            object result = GetResult(millisecondsTimeout, exitContext, cancelWaitHandle, out e);
+            if (null != e)
+            {
+                throw new WorkItemResultException("The work item caused an excpetion, see the inner exception for details", e);
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Get the result of the work item.
+        /// If the work item didn't run yet then the caller waits for the result, timeout, or cancel.
+        /// In case of error the e argument is filled with the exception
+        /// </summary>
+        /// <returns>The result of the work item</returns>
+        private object GetResult(
+            int millisecondsTimeout,
+            bool exitContext,
+            WaitHandle cancelWaitHandle,
+            out Exception e)
+        {
+            e = null;
+
+            // Check for cancel
+            if (WorkItemState.Canceled == GetWorkItemState())
+            {
+                throw new WorkItemCancelException("Work item canceled");
+            }
+
+            // Check for completion
+            if (IsCompleted)
+            {
+                e = _exception;
+                return _result;
+            }
+
+            // If no cancelWaitHandle is provided
+            if (null == cancelWaitHandle)
+            {
+                WaitHandle wh = GetWaitHandle();
+
+                bool timeout = !wh.WaitOne(millisecondsTimeout, exitContext);
+
+                ReleaseWaitHandle();
+
+                if (timeout)
+                {
+                    throw new WorkItemTimeoutException("Work item timeout");
+                }
+            }
+            else
+            {
+                WaitHandle wh = GetWaitHandle();
+                int result = WaitHandle.WaitAny(new WaitHandle[] { wh, cancelWaitHandle });
+                ReleaseWaitHandle();
+
+                switch(result)
+                {
+                    case 0:
+                        // The work item signaled
+                        // Note that the signal could be also as a result of canceling the 
+                        // work item (not the get result)
+                        break;
+                    case 1:
+                    case WaitHandle.WaitTimeout:
+                        throw new WorkItemTimeoutException("Work item timeout");
+                    default:
+                        Debug.Assert(false);
+                        break;
+
+                }
+            }
+
+            // Check for cancel
+            if (WorkItemState.Canceled == GetWorkItemState())
+            {
+                throw new WorkItemCancelException("Work item canceled");
+            }
+
+            Debug.Assert(IsCompleted);
+
+            e = _exception;
+
+            // Return the result
+            return _result;
+        }
+
+        /// <summary>
+        /// A wait handle to wait for completion, cancel, or timeout 
+        /// </summary>
+        private WaitHandle GetWaitHandle()
+        {
+            lock(this)
+            {
+                if (null == _workItemCompleted)
+                {
+                    _workItemCompleted = new ManualResetEvent(IsCompleted);
+                }
+                ++_workItemCompletedRefCount;
+            }
+            return _workItemCompleted;
+        }
+
+        private void ReleaseWaitHandle()
+        {
+            lock(this)
+            {
+                if (null != _workItemCompleted)
+                {
+                    --_workItemCompletedRefCount;
+                    if (0 == _workItemCompletedRefCount)
+                    {
+                        _workItemCompleted.Close();
+                        _workItemCompleted = null;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns true when the work item has completed or canceled
+        /// </summary>
+        private bool IsCompleted
+        {
+            get
+            {
+                lock(this)
+                {
+                    WorkItemState workItemState = GetWorkItemState();
+                    return ((workItemState == WorkItemState.Completed) || 
+                            (workItemState == WorkItemState.Canceled));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns true when the work item has canceled
+        /// </summary>
+        public bool IsCanceled
+        {
+            get
+            {
+                lock(this)
+                {
+                    return (GetWorkItemState() == WorkItemState.Canceled);
+                }
+            }
+        }
+
+        #endregion
+
+        #region IHasWorkItemPriority Members
+
+        /// <summary>
+        /// Returns the priority of the work item
+        /// </summary>
+        public WorkItemPriority WorkItemPriority
+        {
+            get
+            {
+                return _workItemInfo.WorkItemPriority;
+            }
+        }
+
+        #endregion
+
+        internal event WorkItemStateCallback OnWorkItemStarted
+        {
+            add
+            {
+                _workItemStartedEvent += value;
+            }
+            remove
+            {
+                _workItemStartedEvent -= value;
+            }
+        }
+
+        internal event WorkItemStateCallback OnWorkItemCompleted
+        {
+            add
+            {
+                _workItemCompletedEvent += value;
+            }
+            remove
+            {
+                _workItemCompletedEvent -= value;
+            }
+        }
+
+
+        #region WorkItemResult class
+
+        private class WorkItemResult : IWorkItemResult, IInternalWorkItemResult
+        {
+            /// <summary>
+            /// A back reference to the work item
+            /// </summary>
+            private WorkItem _workItem;
+
+            public WorkItemResult(WorkItem workItem)
+            {
+                _workItem = workItem;
+            }
+
+            internal WorkItem GetWorkItem()
+            {
+                return _workItem;
+            }
+
+            #region IWorkItemResult Members
+
+            public bool IsCompleted
+            {
+                get
+                {
+                    return _workItem.IsCompleted;
+                }
+            }
+
+            public void Abort()
+            {
+                _workItem.Abort();
+            }
+
+            public bool IsCanceled
+            {
+                get
+                {
+                    return _workItem.IsCanceled;
+                }
+            }
+
+            public object GetResult()
+            {
+                return _workItem.GetResult(Timeout.Infinite, true, null);
+            }
+    
+            public object GetResult(int millisecondsTimeout, bool exitContext)
+            {
+                return _workItem.GetResult(millisecondsTimeout, exitContext, null);
+            }
+
+            public object GetResult(TimeSpan timeout, bool exitContext)
+            {
+                return _workItem.GetResult((int)timeout.TotalMilliseconds, exitContext, null);
+            }
+
+            public object GetResult(int millisecondsTimeout, bool exitContext, WaitHandle cancelWaitHandle)
+            {
+                return _workItem.GetResult(millisecondsTimeout, exitContext, cancelWaitHandle);
+            }
+
+            public object GetResult(TimeSpan timeout, bool exitContext, WaitHandle cancelWaitHandle)
+            {
+                return _workItem.GetResult((int)timeout.TotalMilliseconds, exitContext, cancelWaitHandle);
+            }
+
+            public object GetResult(out Exception e)
+            {
+                return _workItem.GetResult(Timeout.Infinite, true, null, out e);
+            }
+    
+            public object GetResult(int millisecondsTimeout, bool exitContext, out Exception e)
+            {
+                return _workItem.GetResult(millisecondsTimeout, exitContext, null, out e);
+            }
+
+            public object GetResult(TimeSpan timeout, bool exitContext, out Exception e)
+            {
+                return _workItem.GetResult((int)timeout.TotalMilliseconds, exitContext, null, out e);
+            }
+
+            public object GetResult(int millisecondsTimeout, bool exitContext, WaitHandle cancelWaitHandle, out Exception e)
+            {
+                return _workItem.GetResult(millisecondsTimeout, exitContext, cancelWaitHandle, out e);
+            }
+
+            public object GetResult(TimeSpan timeout, bool exitContext, WaitHandle cancelWaitHandle, out Exception e)
+            {
+                return _workItem.GetResult((int)timeout.TotalMilliseconds, exitContext, cancelWaitHandle, out e);
+            }
+
+            public bool Cancel()
+            {
+                return _workItem.Cancel();
+            }
+
+            public object State
+            {
+                get
+                {
+                    return _workItem._state;
+                }
+            }
+
+            public WorkItemPriority WorkItemPriority 
+            { 
+                get
+                {
+                    return _workItem._workItemInfo.WorkItemPriority;
+                }
+            }
+
+            /// <summary>
+            /// Return the result, same as GetResult()
+            /// </summary>
+            public object Result
+            {
+                get { return GetResult(); }
+            }
+
+            /// <summary>
+            /// Returns the exception if occured otherwise returns null.
+            /// This value is valid only after the work item completed,
+            /// before that it is always null.
+            /// </summary>
+            public object Exception
+            {
+                get { return _workItem._exception; }
+            }
+
+            #endregion
+
+            #region IInternalWorkItemResult Members
+
+            public event WorkItemStateCallback OnWorkItemStarted
+            {
+                add
+                {
+                    _workItem.OnWorkItemStarted += value;
+                }
+                remove
+                {
+                    _workItem.OnWorkItemStarted -= value;
+                }
+            }
+
+
+            public event WorkItemStateCallback OnWorkItemCompleted
+            {
+                add
+                {
+                    _workItem.OnWorkItemCompleted += value;
+                }
+                remove
+                {
+                    _workItem.OnWorkItemCompleted -= value;
+                }
+            }
+
+            #endregion
+        }
+
+        #endregion
+
+        public void DisposeOfState()
+        {
+            if (_workItemInfo.DisposeOfStateObjects)
+            {
+                IDisposable disp = _state as IDisposable;
+                if (null != disp)
+                {
+                    disp.Dispose();
+                    _state = null;
+                }
+            }
+        }
+
+        public void Abort()
+        {
+            lock (this)
+            {
+                if(currentThread != null)
+                    currentThread.Abort();
+            }
+        }
+    }
+    #endregion
+}
diff --git a/ThirdParty/SmartThreadPool/WorkItemFactory.cs b/ThirdParty/SmartThreadPool/WorkItemFactory.cs
new file mode 100644
index 0000000..dfcb54f
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/WorkItemFactory.cs
@@ -0,0 +1,333 @@
+// Ami Bar
+// amibar@gmail.com
+
+using System;
+
+namespace Amib.Threading.Internal
+{
+    #region WorkItemFactory class 
+
+    public class WorkItemFactory
+    {
+        /// <summary>
+        /// Create a new work item
+        /// </summary>
+        /// <param name="wigStartInfo">Work item group start information</param>
+        /// <param name="callback">A callback to execute</param>
+        /// <returns>Returns a work item</returns>
+        public static WorkItem CreateWorkItem(
+            IWorkItemsGroup workItemsGroup,
+            WIGStartInfo wigStartInfo,
+            WorkItemCallback callback)
+        {
+            return CreateWorkItem(workItemsGroup, wigStartInfo, callback, null);
+        }
+
+        /// <summary>
+        /// Create a new work item
+        /// </summary>
+        /// <param name="wigStartInfo">Work item group start information</param>
+        /// <param name="callback">A callback to execute</param>
+        /// <param name="workItemPriority">The priority of the work item</param>
+        /// <returns>Returns a work item</returns>
+        public static WorkItem CreateWorkItem(
+            IWorkItemsGroup workItemsGroup,
+            WIGStartInfo wigStartInfo,
+            WorkItemCallback callback, 
+            WorkItemPriority workItemPriority)
+        {
+            return CreateWorkItem(workItemsGroup, wigStartInfo, callback, null, workItemPriority);
+        }
+
+        /// <summary>
+        /// Create a new work item
+        /// </summary>
+        /// <param name="wigStartInfo">Work item group start information</param>
+        /// <param name="workItemInfo">Work item info</param>
+        /// <param name="callback">A callback to execute</param>
+        /// <returns>Returns a work item</returns>
+        public static WorkItem CreateWorkItem(
+            IWorkItemsGroup workItemsGroup,
+            WIGStartInfo wigStartInfo,
+            WorkItemInfo workItemInfo, 
+            WorkItemCallback callback)
+        {
+            return CreateWorkItem(
+                workItemsGroup,
+                wigStartInfo,
+                workItemInfo, 
+                callback, 
+                null);
+        }
+
+        /// <summary>
+        /// Create a new work item
+        /// </summary>
+        /// <param name="wigStartInfo">Work item group start 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</returns>
+        public static WorkItem CreateWorkItem(
+            IWorkItemsGroup workItemsGroup,
+            WIGStartInfo wigStartInfo,
+            WorkItemCallback callback, 
+            object state)
+        {
+            ValidateCallback(callback);
+
+            WorkItemInfo workItemInfo = new WorkItemInfo();
+            workItemInfo.UseCallerCallContext = wigStartInfo.UseCallerCallContext;
+            workItemInfo.UseCallerHttpContext = wigStartInfo.UseCallerHttpContext;
+            workItemInfo.PostExecuteWorkItemCallback = wigStartInfo.PostExecuteWorkItemCallback;
+            workItemInfo.CallToPostExecute = wigStartInfo.CallToPostExecute;
+            workItemInfo.DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects;
+
+            WorkItem workItem = new WorkItem(
+                workItemsGroup,
+                workItemInfo,
+                callback, 
+                state);
+            return workItem;
+        }
+
+        /// <summary>
+        /// Create a new work item
+        /// </summary>
+        /// <param name="wigStartInfo">Work item group start 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>
+        /// <param name="workItemPriority">The work item priority</param>
+        /// <returns>Returns a work item</returns>
+        public static WorkItem CreateWorkItem(
+            IWorkItemsGroup workItemsGroup,
+            WIGStartInfo wigStartInfo,
+            WorkItemCallback callback, 
+            object state, 
+            WorkItemPriority workItemPriority)
+        {
+            ValidateCallback(callback);
+
+            WorkItemInfo workItemInfo = new WorkItemInfo();
+            workItemInfo.UseCallerCallContext = wigStartInfo.UseCallerCallContext;
+            workItemInfo.UseCallerHttpContext = wigStartInfo.UseCallerHttpContext;
+            workItemInfo.PostExecuteWorkItemCallback = wigStartInfo.PostExecuteWorkItemCallback;
+            workItemInfo.CallToPostExecute = wigStartInfo.CallToPostExecute;
+            workItemInfo.DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects;
+            workItemInfo.WorkItemPriority = workItemPriority;
+
+            WorkItem workItem = new WorkItem(
+                workItemsGroup,
+                workItemInfo,
+                callback, 
+                state);
+
+            return workItem;
+        }
+
+        /// <summary>
+        /// Create a new work item
+        /// </summary>
+        /// <param name="wigStartInfo">Work item group start information</param>
+        /// <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</returns>
+        public static WorkItem CreateWorkItem(
+            IWorkItemsGroup workItemsGroup,
+            WIGStartInfo wigStartInfo,
+            WorkItemInfo workItemInfo, 
+            WorkItemCallback callback, 
+            object state)
+        {
+            ValidateCallback(callback);
+            ValidateCallback(workItemInfo.PostExecuteWorkItemCallback);
+
+            WorkItem workItem = new WorkItem(
+                workItemsGroup,
+                new WorkItemInfo(workItemInfo),
+                callback, 
+                state);
+
+            return workItem;
+        }
+
+        /// <summary>
+        /// Create a new work item
+        /// </summary>
+        /// <param name="wigStartInfo">Work item group start 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>
+        /// <param name="postExecuteWorkItemCallback">
+        /// A delegate to call after the callback completion
+        /// </param>
+        /// <returns>Returns a work item</returns>
+        public static WorkItem CreateWorkItem(
+            IWorkItemsGroup workItemsGroup,
+            WIGStartInfo wigStartInfo,
+            WorkItemCallback callback, 
+            object state,
+            PostExecuteWorkItemCallback postExecuteWorkItemCallback)
+        {
+            ValidateCallback(callback);
+            ValidateCallback(postExecuteWorkItemCallback);
+
+            WorkItemInfo workItemInfo = new WorkItemInfo();
+            workItemInfo.UseCallerCallContext = wigStartInfo.UseCallerCallContext;
+            workItemInfo.UseCallerHttpContext = wigStartInfo.UseCallerHttpContext;
+            workItemInfo.PostExecuteWorkItemCallback = postExecuteWorkItemCallback;
+            workItemInfo.CallToPostExecute = wigStartInfo.CallToPostExecute;
+            workItemInfo.DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects;
+
+            WorkItem workItem = new WorkItem(
+                workItemsGroup,
+                workItemInfo,
+                callback, 
+                state);
+
+            return workItem;
+        }
+
+        /// <summary>
+        /// Create a new work item
+        /// </summary>
+        /// <param name="wigStartInfo">Work item group start 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>
+        /// <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</returns>
+        public static WorkItem CreateWorkItem(
+            IWorkItemsGroup workItemsGroup,
+            WIGStartInfo wigStartInfo,
+            WorkItemCallback callback, 
+            object state,
+            PostExecuteWorkItemCallback postExecuteWorkItemCallback,
+            WorkItemPriority workItemPriority)
+        {
+            ValidateCallback(callback);
+            ValidateCallback(postExecuteWorkItemCallback);
+
+            WorkItemInfo workItemInfo = new WorkItemInfo();
+            workItemInfo.UseCallerCallContext = wigStartInfo.UseCallerCallContext;
+            workItemInfo.UseCallerHttpContext = wigStartInfo.UseCallerHttpContext;
+            workItemInfo.PostExecuteWorkItemCallback = postExecuteWorkItemCallback;
+            workItemInfo.CallToPostExecute = wigStartInfo.CallToPostExecute;
+            workItemInfo.DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects;
+            workItemInfo.WorkItemPriority = workItemPriority;
+
+            WorkItem workItem = new WorkItem(
+                workItemsGroup,
+                workItemInfo,
+                callback, 
+                state);
+
+            return workItem;
+        }
+
+        /// <summary>
+        /// Create a new work item
+        /// </summary>
+        /// <param name="wigStartInfo">Work item group start 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>
+        /// <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</returns>
+        public static WorkItem CreateWorkItem(
+            IWorkItemsGroup workItemsGroup,
+            WIGStartInfo wigStartInfo,
+            WorkItemCallback callback, 
+            object state,
+            PostExecuteWorkItemCallback postExecuteWorkItemCallback,
+            CallToPostExecute callToPostExecute)
+        {
+            ValidateCallback(callback);
+            ValidateCallback(postExecuteWorkItemCallback);
+
+            WorkItemInfo workItemInfo = new WorkItemInfo();
+            workItemInfo.UseCallerCallContext = wigStartInfo.UseCallerCallContext;
+            workItemInfo.UseCallerHttpContext = wigStartInfo.UseCallerHttpContext;
+            workItemInfo.PostExecuteWorkItemCallback = postExecuteWorkItemCallback;
+            workItemInfo.CallToPostExecute = callToPostExecute;
+            workItemInfo.DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects;
+
+            WorkItem workItem = new WorkItem(
+                workItemsGroup,
+                workItemInfo,
+                callback, 
+                state);
+
+            return workItem;
+        }
+
+        /// <summary>
+        /// Create a new work item
+        /// </summary>
+        /// <param name="wigStartInfo">Work item group start 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>
+        /// <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</returns>
+        public static WorkItem CreateWorkItem(
+            IWorkItemsGroup workItemsGroup,
+            WIGStartInfo wigStartInfo,
+            WorkItemCallback callback, 
+            object state,
+            PostExecuteWorkItemCallback postExecuteWorkItemCallback,
+            CallToPostExecute callToPostExecute,
+            WorkItemPriority workItemPriority)
+        {
+
+            ValidateCallback(callback);
+            ValidateCallback(postExecuteWorkItemCallback);
+
+            WorkItemInfo workItemInfo = new WorkItemInfo();
+            workItemInfo.UseCallerCallContext = wigStartInfo.UseCallerCallContext;
+            workItemInfo.UseCallerHttpContext = wigStartInfo.UseCallerHttpContext;
+            workItemInfo.PostExecuteWorkItemCallback = postExecuteWorkItemCallback;
+            workItemInfo.CallToPostExecute = callToPostExecute;
+            workItemInfo.WorkItemPriority = workItemPriority;
+            workItemInfo.DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects;
+
+            WorkItem workItem = new WorkItem(
+                workItemsGroup,
+                workItemInfo,
+                callback, 
+                state);
+            
+            return workItem;
+        }
+
+        private static void ValidateCallback(Delegate callback)
+        {
+            if(callback.GetInvocationList().Length > 1)
+            {
+                throw new NotSupportedException("SmartThreadPool doesn't support delegates chains");
+            }
+        }
+    }
+
+    #endregion
+}
diff --git a/ThirdParty/SmartThreadPool/WorkItemInfo.cs b/ThirdParty/SmartThreadPool/WorkItemInfo.cs
new file mode 100644
index 0000000..c259339
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/WorkItemInfo.cs
@@ -0,0 +1,102 @@
+// Ami Bar
+// amibar@gmail.com
+
+namespace Amib.Threading
+{
+    #region WorkItemInfo class
+
+    /// <summary>
+    /// Summary description for WorkItemInfo.
+    /// </summary>
+    public class WorkItemInfo
+    {
+        /// <summary>
+        /// Use the caller's security context
+        /// </summary>
+        private bool _useCallerCallContext;
+
+        /// <summary>
+        /// Use the caller's security context
+        /// </summary>
+        private bool _useCallerHttpContext;
+
+        /// <summary>
+        /// Dispose of the state object of a work item
+        /// </summary>
+        private bool _disposeOfStateObjects;
+
+        /// <summary>
+        /// The option to run the post execute
+        /// </summary>
+        private CallToPostExecute _callToPostExecute;
+
+        /// <summary>
+        /// A post execute callback to call when none is provided in 
+        /// the QueueWorkItem method.
+        /// </summary>
+        private PostExecuteWorkItemCallback _postExecuteWorkItemCallback;
+        
+        /// <summary>
+        /// The priority of the work item
+        /// </summary>
+        private WorkItemPriority _workItemPriority;
+
+        public WorkItemInfo()
+        {
+            _useCallerCallContext = SmartThreadPool.DefaultUseCallerCallContext;
+            _useCallerHttpContext = SmartThreadPool.DefaultUseCallerHttpContext;
+            _disposeOfStateObjects = SmartThreadPool.DefaultDisposeOfStateObjects;
+            _callToPostExecute = SmartThreadPool.DefaultCallToPostExecute;
+            _postExecuteWorkItemCallback = SmartThreadPool.DefaultPostExecuteWorkItemCallback;
+            _workItemPriority = SmartThreadPool.DefaultWorkItemPriority;
+        }
+
+        public WorkItemInfo(WorkItemInfo workItemInfo)
+        {
+            _useCallerCallContext = workItemInfo._useCallerCallContext;
+            _useCallerHttpContext = workItemInfo._useCallerHttpContext;
+            _disposeOfStateObjects = workItemInfo._disposeOfStateObjects;
+            _callToPostExecute = workItemInfo._callToPostExecute;
+            _postExecuteWorkItemCallback = workItemInfo._postExecuteWorkItemCallback;
+            _workItemPriority = workItemInfo._workItemPriority;
+        }
+
+        public bool UseCallerCallContext
+        {
+            get { return _useCallerCallContext; }
+            set { _useCallerCallContext = value; }
+        }
+
+        public bool UseCallerHttpContext
+        {
+            get { return _useCallerHttpContext; }
+            set { _useCallerHttpContext = value; }
+        }
+
+        public bool DisposeOfStateObjects
+        {
+            get { return _disposeOfStateObjects; }
+            set { _disposeOfStateObjects = value; }
+        }
+
+        public CallToPostExecute CallToPostExecute
+        {
+            get { return _callToPostExecute; }
+            set { _callToPostExecute = value; }
+        }
+
+        public PostExecuteWorkItemCallback PostExecuteWorkItemCallback
+        {
+            get { return _postExecuteWorkItemCallback; }
+            set { _postExecuteWorkItemCallback = value; }
+        }
+
+        public WorkItemPriority WorkItemPriority
+        {
+            get { return _workItemPriority; }
+            set { _workItemPriority = value; }
+        }
+    }
+
+    #endregion
+}
diff --git a/ThirdParty/SmartThreadPool/WorkItemsGroup.cs b/ThirdParty/SmartThreadPool/WorkItemsGroup.cs
new file mode 100644
index 0000000..01ac8dd
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/WorkItemsGroup.cs
@@ -0,0 +1,512 @@
+// Ami Bar
+// amibar@gmail.com
+
+using System;
+using System.Threading;
+using System.Runtime.CompilerServices;
+using System.Diagnostics;
+
+namespace Amib.Threading.Internal
+{
+    #region WorkItemsGroup class 
+
+    /// <summary>
+    /// Summary description for WorkItemsGroup.
+    /// </summary>
+    public class WorkItemsGroup : IWorkItemsGroup
+    {
+        #region Private members
+
+        private object _lock = new object();
+        /// <summary>
+        /// Contains the name of this instance of SmartThreadPool.
+        /// Can be changed by the user.
+        /// </summary>
+        private string _name = "WorkItemsGroup";
+
+        /// <summary>
+        /// A reference to the SmartThreadPool instance that created this 
+        /// WorkItemsGroup.
+        /// </summary>
+        private SmartThreadPool _stp;
+
+        /// <summary>
+        /// The OnIdle event
+        /// </summary>
+        private event WorkItemsGroupIdleHandler _onIdle;
+
+        /// <summary>
+        /// Defines how many work items of this WorkItemsGroup can run at once.
+        /// </summary>
+        private int _concurrency;
+
+        /// <summary>
+        /// Priority queue to hold work items before they are passed 
+        /// to the SmartThreadPool.
+        /// </summary>
+        private PriorityQueue _workItemsQueue;
+
+        /// <summary>
+        /// Indicate how many work items are waiting in the SmartThreadPool
+        /// queue.
+        /// This value is used to apply the concurrency.
+        /// </summary>
+        private int _workItemsInStpQueue;
+
+        /// <summary>
+        /// Indicate how many work items are currently running in the SmartThreadPool.
+        /// This value is used with the Cancel, to calculate if we can send new 
+        /// work items to the STP.
+        /// </summary>
+        private int _workItemsExecutingInStp = 0;
+
+        /// <summary>
+        /// WorkItemsGroup start information
+        /// </summary>
+        private WIGStartInfo _workItemsGroupStartInfo;
+
+        /// <summary>
+        /// Signaled when all of the WorkItemsGroup's work item completed.
+        /// </summary>
+        private ManualResetEvent _isIdleWaitHandle = new ManualResetEvent(true);
+
+        /// <summary>
+        /// A common object for all the work items that this work items group
+        /// generate so we can mark them to cancel in O(1)
+        /// </summary>
+        private CanceledWorkItemsGroup _canceledWorkItemsGroup = new CanceledWorkItemsGroup();
+
+        #endregion 
+
+        #region Construction
+
+        public WorkItemsGroup(
+            SmartThreadPool stp, 
+            int concurrency, 
+            WIGStartInfo wigStartInfo)
+        {
+            if (concurrency <= 0)
+            {
+                throw new ArgumentOutOfRangeException("concurrency", concurrency, "concurrency must be greater than zero");
+            }
+            _stp = stp;
+            _concurrency = concurrency;
+            _workItemsGroupStartInfo = new WIGStartInfo(wigStartInfo);
+            _workItemsQueue = new PriorityQueue();
+
+            // The _workItemsInStpQueue gets the number of currently executing work items,
+            // because once a work item is executing, it cannot be cancelled.
+            _workItemsInStpQueue = _workItemsExecutingInStp;
+        }
+
+        #endregion 
+
+        #region IWorkItemsGroup implementation
+
+        /// <summary>
+        /// Get/Set the name of the SmartThreadPool instance
+        /// </summary>
+        public string Name 
+        { 
+            get
+            {
+                return _name;
+            }
+
+            set
+            {
+                _name = value;
+            }
+        }
+
+        /// <summary>
+        /// Queue a work item
+        /// </summary>
+        /// <param name="callback">A callback to execute</param>
+        /// <returns>Returns a work item result</returns>
+        public IWorkItemResult QueueWorkItem(WorkItemCallback callback)
+        {
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback);
+            EnqueueToSTPNextWorkItem(workItem);
+            return workItem.GetWorkItemResult();
+        }
+
+        /// <summary>
+        /// Queue a work item
+        /// </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)
+        {
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback, workItemPriority);
+            EnqueueToSTPNextWorkItem(workItem);
+            return workItem.GetWorkItemResult();
+        }
+
+        /// <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)
+        {
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, workItemInfo, callback);
+            EnqueueToSTPNextWorkItem(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>
+        /// <returns>Returns a work item result</returns>
+        public IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state)
+        {
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback, state);
+            EnqueueToSTPNextWorkItem(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="workItemPriority">The work item priority</param>
+        /// <returns>Returns a work item result</returns>
+        public IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state, WorkItemPriority workItemPriority)
+        {
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback, state, workItemPriority);
+            EnqueueToSTPNextWorkItem(workItem);
+            return workItem.GetWorkItemResult();
+        }
+
+        /// <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)
+        {
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, workItemInfo, callback, state);
+            EnqueueToSTPNextWorkItem(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>
+        /// <returns>Returns a work item result</returns>
+        public IWorkItemResult QueueWorkItem(
+            WorkItemCallback callback, 
+            object state,
+            PostExecuteWorkItemCallback postExecuteWorkItemCallback)
+        {
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback, state, postExecuteWorkItemCallback);
+            EnqueueToSTPNextWorkItem(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="workItemPriority">The work item priority</param>
+        /// <returns>Returns a work item result</returns>
+        public IWorkItemResult QueueWorkItem(
+            WorkItemCallback callback, 
+            object state,
+            PostExecuteWorkItemCallback postExecuteWorkItemCallback,
+            WorkItemPriority workItemPriority)
+        {
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback, state, postExecuteWorkItemCallback, workItemPriority);
+            EnqueueToSTPNextWorkItem(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>
+        /// <returns>Returns a work item result</returns>
+        public IWorkItemResult QueueWorkItem(
+            WorkItemCallback callback, 
+            object state,
+            PostExecuteWorkItemCallback postExecuteWorkItemCallback,
+            CallToPostExecute callToPostExecute)
+        {
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback, state, postExecuteWorkItemCallback, callToPostExecute);
+            EnqueueToSTPNextWorkItem(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)
+        {
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, _workItemsGroupStartInfo, callback, state, postExecuteWorkItemCallback, callToPostExecute, workItemPriority);
+            EnqueueToSTPNextWorkItem(workItem);
+            return workItem.GetWorkItemResult();
+        }
+
+        /// <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);
+        }
+
+        /// <summary>
+        /// Wait for the thread pool to be idle
+        /// </summary>
+        public bool WaitForIdle(int millisecondsTimeout)
+        {
+            _stp.ValidateWorkItemsGroupWaitForIdle(this);
+            return _isIdleWaitHandle.WaitOne(millisecondsTimeout, false);
+        }
+
+        public int WaitingCallbacks
+        {
+            get
+            {
+                return _workItemsQueue.Count;
+            }
+        }
+
+        public event WorkItemsGroupIdleHandler OnIdle
+        {
+            add
+            {
+                _onIdle += value;
+            }
+            remove
+            {
+                _onIdle -= value;
+            }
+        }
+
+        public void Cancel()
+        {
+            lock(_lock)
+            {
+                _canceledWorkItemsGroup.IsCanceled = true;
+                _workItemsQueue.Clear();
+                _workItemsInStpQueue = 0;
+                _canceledWorkItemsGroup = new CanceledWorkItemsGroup();
+            }
+        }
+
+        public void Start()
+        {
+            lock (this)
+            {
+                if (!_workItemsGroupStartInfo.StartSuspended)
+                {
+                    return;
+                }
+                _workItemsGroupStartInfo.StartSuspended = false;
+            }
+            
+            for(int i = 0; i < _concurrency; ++i)
+            {
+                EnqueueToSTPNextWorkItem(null, false);
+            }
+        }
+
+        #endregion 
+
+        #region Private methods
+
+        private void RegisterToWorkItemCompletion(IWorkItemResult wir)
+        {
+            IInternalWorkItemResult iwir = wir as IInternalWorkItemResult;
+            iwir.OnWorkItemStarted += new WorkItemStateCallback(OnWorkItemStartedCallback);
+            iwir.OnWorkItemCompleted += new WorkItemStateCallback(OnWorkItemCompletedCallback);
+        }
+
+        public void OnSTPIsStarting()
+        {
+            lock (this)
+            {
+                if (_workItemsGroupStartInfo.StartSuspended)
+                {
+                    return;
+                }
+            }
+            
+            for(int i = 0; i < _concurrency; ++i)
+            {
+                EnqueueToSTPNextWorkItem(null, false);
+            }
+        }
+
+        private object FireOnIdle(object state)
+        {
+            FireOnIdleImpl(_onIdle);
+            return null;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void FireOnIdleImpl(WorkItemsGroupIdleHandler onIdle)
+        {
+            if(null == onIdle)
+            {
+                return;
+            }
+
+            Delegate[] delegates = onIdle.GetInvocationList();
+            foreach(WorkItemsGroupIdleHandler eh in delegates)
+            {
+                try
+                {
+                    eh(this);
+                }
+                    // Ignore exceptions
+                catch{} 
+            }
+        }
+
+        private void OnWorkItemStartedCallback(WorkItem workItem)
+        {
+            lock(_lock)
+            {
+                ++_workItemsExecutingInStp;
+            }
+        }
+
+        private void OnWorkItemCompletedCallback(WorkItem workItem)
+        {
+            EnqueueToSTPNextWorkItem(null, true);
+        }
+
+        private void EnqueueToSTPNextWorkItem(WorkItem workItem)
+        {
+            EnqueueToSTPNextWorkItem(workItem, false);
+        }
+
+        private void EnqueueToSTPNextWorkItem(WorkItem workItem, bool decrementWorkItemsInStpQueue)
+        {
+            lock(_lock)
+            {
+                // Got here from OnWorkItemCompletedCallback()
+                if (decrementWorkItemsInStpQueue)
+                {
+                    --_workItemsInStpQueue;
+
+                    if(_workItemsInStpQueue < 0)
+                    {
+                        _workItemsInStpQueue = 0;
+                    }
+
+                    --_workItemsExecutingInStp;
+
+                    if(_workItemsExecutingInStp < 0)
+                    {
+                        _workItemsExecutingInStp = 0;
+                    }
+                }
+
+                // If the work item is not null then enqueue it
+                if (null != workItem)
+                {
+                    workItem.CanceledWorkItemsGroup = _canceledWorkItemsGroup;
+
+                    RegisterToWorkItemCompletion(workItem.GetWorkItemResult());
+                    _workItemsQueue.Enqueue(workItem);
+                    //_stp.IncrementWorkItemsCount();
+
+                    if ((1 == _workItemsQueue.Count) && 
+                        (0 == _workItemsInStpQueue))
+                    {
+                        _stp.RegisterWorkItemsGroup(this);
+                        Trace.WriteLine("WorkItemsGroup " + Name + " is NOT idle");
+                        _isIdleWaitHandle.Reset();
+                    }
+                }
+
+                // If the work items queue of the group is empty than quit
+                if (0 == _workItemsQueue.Count)
+                {
+                    if (0 == _workItemsInStpQueue)
+                    {
+                        _stp.UnregisterWorkItemsGroup(this);
+                        Trace.WriteLine("WorkItemsGroup " + Name + " is idle");
+                        _isIdleWaitHandle.Set();
+                        _stp.QueueWorkItem(new WorkItemCallback(this.FireOnIdle));
+                    }
+                    return;
+                }
+
+                if (!_workItemsGroupStartInfo.StartSuspended)
+                {
+                    if (_workItemsInStpQueue < _concurrency)
+                    {
+                        WorkItem nextWorkItem = _workItemsQueue.Dequeue() as WorkItem;
+                        _stp.Enqueue(nextWorkItem, true);
+                        ++_workItemsInStpQueue;
+                    }
+                }
+            }
+        }
+
+        #endregion
+    }
+
+    #endregion
+}
diff --git a/ThirdParty/SmartThreadPool/WorkItemsQueue.cs b/ThirdParty/SmartThreadPool/WorkItemsQueue.cs
new file mode 100644
index 0000000..af5af07
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/WorkItemsQueue.cs
@@ -0,0 +1,600 @@
+// Ami Bar
+// amibar@gmail.com
+
+using System;
+using System.Threading;
+
+namespace Amib.Threading.Internal
+{
+    #region WorkItemsQueue class
+
+    /// <summary>
+    /// WorkItemsQueue class.
+    /// </summary>
+    public class WorkItemsQueue : IDisposable
+    {
+        #region Member variables
+
+        /// <summary>
+        /// Waiters queue (implemented as stack).
+        /// </summary>
+        private WaiterEntry _headWaiterEntry = new WaiterEntry();
+
+        /// <summary>
+        /// Waiters count
+        /// </summary>
+        private int _waitersCount = 0;
+
+        /// <summary>
+        /// Work items queue
+        /// </summary>
+        private PriorityQueue _workItems = new PriorityQueue();
+
+        /// <summary>
+        /// Indicate that work items are allowed to be queued
+        /// </summary>
+        private bool _isWorkItemsQueueActive = true;
+
+        /// <summary>
+        /// Each thread in the thread pool keeps its own waiter entry.
+        /// </summary>
+        [ThreadStatic]
+        private static WaiterEntry _waiterEntry;
+
+        /// <summary>
+        /// A flag that indicates if the WorkItemsQueue has been disposed.
+        /// </summary>
+        private bool _isDisposed = false;
+
+        #endregion
+
+        #region Public properties
+
+        /// <summary>
+        /// Returns the current number of work items in the queue
+        /// </summary>
+        public int Count
+        {
+            get
+            {
+                lock(this)
+                {
+                    ValidateNotDisposed();
+                    return _workItems.Count;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns the current number of waiters
+        /// </summary>
+        public int WaitersCount
+        {
+            get
+            {
+                lock(this)
+                {
+                    ValidateNotDisposed();
+                    return _waitersCount;
+                }
+            }
+        }
+
+
+        #endregion
+
+        #region Public methods
+
+        /// <summary>
+        /// Enqueue a work item to the queue.
+        /// </summary>
+        public bool EnqueueWorkItem(WorkItem workItem)
+        {
+            // A work item cannot be null, since null is used in the
+            // WaitForWorkItem() method to indicate timeout or cancel
+            if (null == workItem)
+            {
+                throw new ArgumentNullException("workItem" , "workItem cannot be null");
+            }
+
+            bool enqueue = true;
+
+            // First check if there is a waiter waiting for work item. During 
+            // the check, timed out waiters are ignored. If there is no 
+            // waiter then the work item is queued.
+            lock(this)
+            {
+                ValidateNotDisposed();
+
+                if (!_isWorkItemsQueueActive)
+                {
+                    return false;
+                }
+
+                while(_waitersCount > 0)
+                {
+                    // Dequeue a waiter.
+                    WaiterEntry waiterEntry = PopWaiter();
+
+                    // Signal the waiter. On success break the loop
+                    if (waiterEntry.Signal(workItem))
+                    {
+                        enqueue = false;
+                        break;
+                    }
+                }
+
+                if (enqueue)
+                {
+                    // Enqueue the work item
+                    _workItems.Enqueue(workItem);
+                }
+            }
+            return true;
+        }
+
+
+        /// <summary>
+        /// Waits for a work item or exits on timeout or cancel
+        /// </summary>
+        /// <param name="millisecondsTimeout">Timeout in milliseconds</param>
+        /// <param name="cancelEvent">Cancel wait handle</param>
+        /// <returns>Returns true if the resource was granted</returns>
+        public WorkItem DequeueWorkItem(
+            int millisecondsTimeout, 
+            WaitHandle cancelEvent)
+        {
+            /// This method cause the caller to wait for a work item.
+            /// If there is at least one waiting work item then the 
+            /// method returns immidiately with true.
+            /// 
+            /// If there are no waiting work items then the caller 
+            /// is queued between other waiters for a work item to arrive.
+            /// 
+            /// If a work item didn't come within millisecondsTimeout or 
+            /// the user canceled the wait by signaling the cancelEvent 
+            /// then the method returns false to indicate that the caller 
+            /// didn't get a work item.
+
+            WaiterEntry waiterEntry = null;
+            WorkItem workItem = null;
+
+            lock(this)
+            {
+                ValidateNotDisposed();
+
+                // If there are waiting work items then take one and return.
+                if (_workItems.Count > 0)
+                {
+                    workItem = _workItems.Dequeue() as WorkItem;
+                    return workItem;
+                }
+                    // No waiting work items ...
+                else
+                {
+                    // Get the wait entry for the waiters queue
+                    waiterEntry = GetThreadWaiterEntry();
+
+                    // Put the waiter with the other waiters
+                    PushWaiter(waiterEntry);
+                }
+            }
+
+            // Prepare array of wait handle for the WaitHandle.WaitAny()
+            WaitHandle [] waitHandles = new WaitHandle [] { 
+                                                                waiterEntry.WaitHandle, 
+                                                                cancelEvent };
+
+            // Wait for an available resource, cancel event, or timeout.
+
+            // During the wait we are supposes to exit the synchronization 
+            // domain. (Placing true as the third argument of the WaitAny())
+            // It just doesn't work, I don't know why, so I have lock(this) 
+            // statments insted of one.
+
+            int index = WaitHandle.WaitAny(
+                waitHandles,
+                millisecondsTimeout, 
+                true);
+
+            lock(this)
+            {
+                // success is true if it got a work item.
+                bool success = (0 == index);
+
+                // The timeout variable is used only for readability.
+                // (We treat cancel as timeout)
+                bool timeout = !success;
+
+                // On timeout update the waiterEntry that it is timed out
+                if (timeout)
+                {
+                    // The Timeout() fails if the waiter has already been signaled
+                    timeout = waiterEntry.Timeout();
+
+                    // On timeout remove the waiter from the queue.
+                    // Note that the complexity is O(1).
+                    if(timeout)
+                    {
+                        RemoveWaiter(waiterEntry, false);
+                    }
+
+                    // Again readability
+                    success = !timeout;
+                }
+
+                // On success return the work item
+                if (success)
+                {
+                    workItem = waiterEntry.WorkItem;
+
+                    if (null == workItem)
+                    {
+                        workItem = _workItems.Dequeue() as WorkItem;
+                    }
+                }
+            }
+            // On failure return null.
+            return workItem;
+        }
+
+        /// <summary>
+        /// Cleanup the work items queue, hence no more work 
+        /// items are allowed to be queue
+        /// </summary>
+        protected virtual void Cleanup()
+        {
+            lock(this)
+            {
+                // Deactivate only once
+                if (!_isWorkItemsQueueActive)
+                {
+                    return;
+                }
+
+                // Don't queue more work items
+                _isWorkItemsQueueActive = false;
+
+                foreach(WorkItem workItem in _workItems)
+                {
+                    workItem.DisposeOfState();
+                }
+
+                // Clear the work items that are already queued
+                _workItems.Clear();
+
+                // Note: 
+                // I don't iterate over the queue and dispose of work items's states, 
+                // since if a work item has a state object that is still in use in the 
+                // application then I must not dispose it.
+
+                // Tell the waiters that they were timed out.
+                // It won't signal them to exit, but to ignore their
+                // next work item.
+                while(_waitersCount > 0)
+                {
+                    WaiterEntry waiterEntry = PopWaiter();
+                    waiterEntry.Timeout();
+                }
+            }
+        }
+
+        #endregion
+
+        #region Private methods
+
+        /// <summary>
+        /// Returns the WaiterEntry of the current thread
+        /// </summary>
+        /// <returns></returns>
+        /// In order to avoid creation and destuction of WaiterEntry
+        /// objects each thread has its own WaiterEntry object.
+        private WaiterEntry GetThreadWaiterEntry()
+        {
+            if (null == _waiterEntry)
+            {
+                _waiterEntry = new WaiterEntry();
+            }
+            _waiterEntry.Reset();
+            return _waiterEntry;
+        }
+
+        #region Waiters stack methods
+
+        /// <summary>
+        /// Push a new waiter into the waiter's stack
+        /// </summary>
+        /// <param name="newWaiterEntry">A waiter to put in the stack</param>
+        public void PushWaiter(WaiterEntry newWaiterEntry)
+        {
+            // Remove the waiter if it is already in the stack and 
+            // update waiter's count as needed
+            RemoveWaiter(newWaiterEntry, false);
+
+            // If the stack is empty then newWaiterEntry is the new head of the stack 
+            if (null == _headWaiterEntry._nextWaiterEntry)
+            {
+                _headWaiterEntry._nextWaiterEntry = newWaiterEntry;
+                newWaiterEntry._prevWaiterEntry = _headWaiterEntry;
+
+            }
+            // If the stack is not empty then put newWaiterEntry as the new head 
+            // of the stack.
+            else
+            {
+                // Save the old first waiter entry
+                WaiterEntry oldFirstWaiterEntry = _headWaiterEntry._nextWaiterEntry;
+
+                // Update the links
+                _headWaiterEntry._nextWaiterEntry = newWaiterEntry;
+                newWaiterEntry._nextWaiterEntry = oldFirstWaiterEntry;
+                newWaiterEntry._prevWaiterEntry = _headWaiterEntry;
+                oldFirstWaiterEntry._prevWaiterEntry = newWaiterEntry;
+            }
+
+            // Increment the number of waiters
+            ++_waitersCount;
+        }
+
+        /// <summary>
+        /// Pop a waiter from the waiter's stack
+        /// </summary>
+        /// <returns>Returns the first waiter in the stack</returns>
+        private WaiterEntry PopWaiter()
+        {
+            // Store the current stack head
+            WaiterEntry oldFirstWaiterEntry = _headWaiterEntry._nextWaiterEntry;
+
+            // Store the new stack head
+            WaiterEntry newHeadWaiterEntry = oldFirstWaiterEntry._nextWaiterEntry;
+
+            // Update the old stack head list links and decrement the number
+            // waiters.
+            RemoveWaiter(oldFirstWaiterEntry, true);
+
+            // Update the new stack head
+            _headWaiterEntry._nextWaiterEntry = newHeadWaiterEntry;
+            if (null != newHeadWaiterEntry)
+            {
+                newHeadWaiterEntry._prevWaiterEntry = _headWaiterEntry;
+            }
+
+            // Return the old stack head
+            return oldFirstWaiterEntry;
+        }
+
+        /// <summary>
+        /// Remove a waiter from the stack
+        /// </summary>
+        /// <param name="waiterEntry">A waiter entry to remove</param>
+        /// <param name="popDecrement">If true the waiter count is always decremented</param>
+        private void RemoveWaiter(WaiterEntry waiterEntry, bool popDecrement)
+        {
+            // Store the prev entry in the list
+            WaiterEntry prevWaiterEntry = waiterEntry._prevWaiterEntry;
+
+            // Store the next entry in the list
+            WaiterEntry nextWaiterEntry = waiterEntry._nextWaiterEntry;
+
+            // A flag to indicate if we need to decrement the waiters count.
+            // If we got here from PopWaiter then we must decrement.
+            // If we got here from PushWaiter then we decrement only if
+            // the waiter was already in the stack.
+            bool decrementCounter = popDecrement;
+
+            // Null the waiter's entry links
+            waiterEntry._prevWaiterEntry = null;
+            waiterEntry._nextWaiterEntry = null;
+
+            // If the waiter entry had a prev link then update it.
+            // It also means that the waiter is already in the list and we
+            // need to decrement the waiters count.
+            if (null != prevWaiterEntry)
+            {
+                prevWaiterEntry._nextWaiterEntry = nextWaiterEntry;
+                decrementCounter = true;
+            }
+
+            // If the waiter entry had a next link then update it.
+            // It also means that the waiter is already in the list and we
+            // need to decrement the waiters count.
+            if (null != nextWaiterEntry)
+            {
+                nextWaiterEntry._prevWaiterEntry = prevWaiterEntry;
+                decrementCounter = true;
+            }
+
+            // Decrement the waiters count if needed
+            if (decrementCounter)
+            {
+                --_waitersCount;
+            }
+        }
+
+        #endregion
+
+        #endregion
+
+        #region WaiterEntry class 
+
+        // A waiter entry in the _waiters queue.
+        public class WaiterEntry : IDisposable
+        {
+            #region Member variables
+
+            /// <summary>
+            /// Event to signal the waiter that it got the work item.
+            /// </summary>
+            private AutoResetEvent _waitHandle = new AutoResetEvent(false);
+
+            /// <summary>
+            /// Flag to know if this waiter already quited from the queue 
+            /// because of a timeout.
+            /// </summary>
+            private bool _isTimedout = false;
+
+            /// <summary>
+            /// Flag to know if the waiter was signaled and got a work item. 
+            /// </summary>
+            private bool _isSignaled = false;
+
+            /// <summary>
+            /// A work item that passed directly to the waiter withou going 
+            /// through the queue
+            /// </summary>
+            private WorkItem _workItem = null;
+
+            private bool _isDisposed = false;
+
+            // Linked list members
+            internal WaiterEntry _nextWaiterEntry = null;
+            internal WaiterEntry _prevWaiterEntry = null;
+
+            #endregion
+
+            #region Construction
+
+            public WaiterEntry()
+            {
+                Reset();
+            }
+                        
+            #endregion
+
+            #region Public methods
+
+            public WaitHandle WaitHandle
+            {
+                get { return _waitHandle; }
+            }
+
+            public WorkItem WorkItem
+            {
+                get
+                {
+                    lock(this)
+                    {
+                        return _workItem;
+                    }
+                }
+            }
+
+            /// <summary>
+            /// Signal the waiter that it got a work item.
+            /// </summary>
+            /// <returns>Return true on success</returns>
+            /// The method fails if Timeout() preceded its call
+            public bool Signal(WorkItem workItem)
+            {
+                lock(this)
+                {
+                    if (!_isTimedout)
+                    {
+                        _workItem = workItem;
+                        _isSignaled = true;
+                        _waitHandle.Set();
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            /// <summary>
+            /// Mark the wait entry that it has been timed out
+            /// </summary>
+            /// <returns>Return true on success</returns>
+            /// The method fails if Signal() preceded its call
+            public bool Timeout()
+            {
+                lock(this)
+                {
+                    // Time out can happen only if the waiter wasn't marked as
+                    // signaled
+                    if (!_isSignaled)
+                    {
+                        // We don't remove the waiter from the queue, the DequeueWorkItem 
+                        // method skips _waiters that were timed out.
+                        _isTimedout = true;
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            /// <summary>
+            /// Reset the wait entry so it can be used again
+            /// </summary>
+            public void Reset()
+            {
+                _workItem = null;
+                _isTimedout = false;
+                _isSignaled = false;
+                _waitHandle.Reset();
+            }
+
+            /// <summary>
+            /// Free resources
+            /// </summary>
+            public void Close()
+            {
+                if (null != _waitHandle)
+                {
+                    _waitHandle.Close();
+                    _waitHandle = null;
+                }
+            }
+
+            #endregion
+
+            #region IDisposable Members
+
+            public void Dispose()
+            {
+                if (!_isDisposed)
+                {
+                    Close();
+                    _isDisposed = true;
+                }
+            }
+
+            ~WaiterEntry()
+            {
+                Dispose();
+            }
+
+            #endregion
+        }
+
+        #endregion
+
+        #region IDisposable Members
+
+        public void Dispose()
+        {
+            if (!_isDisposed)
+            {
+                Cleanup();
+                _isDisposed = true;
+                GC.SuppressFinalize(this);
+            }
+        }
+
+        ~WorkItemsQueue()
+        {
+            Cleanup();
+        }
+
+        private void ValidateNotDisposed()
+        {
+            if(_isDisposed)
+            {
+                throw new ObjectDisposedException(GetType().ToString(), "The SmartThreadPool has been shutdown");
+            }
+        }
+
+        #endregion
+    }
+
+    #endregion
+}
+