From 206fb306a7820cf593570e35ddfa8e7c5a10e449 Mon Sep 17 00:00:00 2001
From: Justin Clark-Casey (justincc)
Date: Wed, 1 May 2013 19:01:43 +0100
Subject: Update SmartThreadPool to latest version 2.2.3 with a major and minor
 change.

SmartThreadPool code comes from http://www.codeproject.com/Articles/7933/Smart-Thread-Pool
This version implements thread abort (via WorkItem.Cancel(true)), threadpool naming, max thread stack, etc. so we no longer need to manually patch those.
However, two changes have been made to stock 2.2.3.
Major change: WorkItem.Cancel(bool abortExecution) in our version does not succeed if the work item was in progress and thread abort was not specified.
This is to match previous behaviour where we handle co-operative termination via another mechanism rather than checking WorkItem.IsCanceled.
Minor change: Did not add STP's StopWatch implementation as this is only used WinCE and Silverlight and causes a build clash with System.Diagnostics.StopWatch
The reason for updating is to see if this improves http://opensimulator.org/mantis/view.php?id=6557 and http://opensimulator.org/mantis/view.php?id=6586
---
 ThirdParty/SmartThreadPool/WorkItemsGroupBase.cs | 471 +++++++++++++++++++++++
 1 file changed, 471 insertions(+)
 create mode 100644 ThirdParty/SmartThreadPool/WorkItemsGroupBase.cs

(limited to 'ThirdParty/SmartThreadPool/WorkItemsGroupBase.cs')

diff --git a/ThirdParty/SmartThreadPool/WorkItemsGroupBase.cs b/ThirdParty/SmartThreadPool/WorkItemsGroupBase.cs
new file mode 100644
index 0000000..429de12
--- /dev/null
+++ b/ThirdParty/SmartThreadPool/WorkItemsGroupBase.cs
@@ -0,0 +1,471 @@
+using System;
+using System.Threading;
+
+namespace Amib.Threading.Internal
+{
+    public abstract class WorkItemsGroupBase : IWorkItemsGroup
+    {
+        #region Private Fields
+
+        /// <summary>
+        /// Contains the name of this instance of SmartThreadPool.
+        /// Can be changed by the user.
+        /// </summary>
+        private string _name = "WorkItemsGroupBase";
+
+        public WorkItemsGroupBase()
+        {
+            IsIdle = true;
+        }
+
+        #endregion
+
+        #region IWorkItemsGroup Members
+
+        #region Public Methods
+
+        /// <summary>
+        /// Get/Set the name of the SmartThreadPool/WorkItemsGroup instance
+        /// </summary>
+        public string Name
+        {
+            get { return _name; }
+            set { _name = value; }
+        }
+
+        #endregion
+
+        #region Abstract Methods
+
+        public abstract int Concurrency { get; set; }
+        public abstract int WaitingCallbacks { get; }
+        public abstract object[] GetStates();
+        public abstract WIGStartInfo WIGStartInfo { get; }
+        public abstract void Start();
+        public abstract void Cancel(bool abortExecution);
+        public abstract bool WaitForIdle(int millisecondsTimeout);
+        public abstract event WorkItemsGroupIdleHandler OnIdle;
+
+        internal abstract void Enqueue(WorkItem workItem);
+        internal virtual void PreQueueWorkItem() { }
+
+        #endregion
+
+        #region Common Base Methods
+
+        /// <summary>
+        /// Cancel all the work items.
+        /// Same as Cancel(false)
+        /// </summary>
+        public virtual void Cancel()
+        {
+            Cancel(false);
+        }
+
+        /// <summary>
+        /// Wait for the SmartThreadPool/WorkItemsGroup to be idle
+        /// </summary>
+        public void WaitForIdle()
+        {
+            WaitForIdle(Timeout.Infinite);
+        }
+
+        /// <summary>
+        /// Wait for the SmartThreadPool/WorkItemsGroup to be idle
+        /// </summary>
+        public bool WaitForIdle(TimeSpan timeout)
+        {
+            return WaitForIdle((int)timeout.TotalMilliseconds);
+        }
+
+        /// <summary>
+        /// IsIdle is true when there are no work items running or queued.
+        /// </summary>
+        public bool IsIdle { get; protected set; }
+
+        #endregion
+
+        #region QueueWorkItem
+
+        /// <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, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, callback, state, postExecuteWorkItemCallback, callToPostExecute, workItemPriority);
+            Enqueue(workItem);
+            return workItem.GetWorkItemResult();
+        }
+
+        #endregion
+
+        #region QueueWorkItem(Action<...>)
+
+        public IWorkItemResult QueueWorkItem(Action action)
+        {
+            return QueueWorkItem (action, SmartThreadPool.DefaultWorkItemPriority);
+        }
+
+        public IWorkItemResult QueueWorkItem (Action action, WorkItemPriority priority)
+        {
+            PreQueueWorkItem ();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem (
+                this,
+                WIGStartInfo,
+                delegate
+                {
+                    action.Invoke ();
+                    return null;
+                }, priority);
+            Enqueue (workItem);
+            return workItem.GetWorkItemResult ();
+        }
+
+        public IWorkItemResult QueueWorkItem<T>(Action<T> action, T arg)
+        {
+            return QueueWorkItem<T> (action, arg, SmartThreadPool.DefaultWorkItemPriority);
+        }
+
+        public IWorkItemResult QueueWorkItem<T> (Action<T> action, T arg, WorkItemPriority priority)
+        {
+            PreQueueWorkItem ();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem (
+                this,
+                WIGStartInfo,
+                state =>
+                {
+                    action.Invoke (arg);
+                    return null;
+                },
+                WIGStartInfo.FillStateWithArgs ? new object[] { arg } : null, priority);
+            Enqueue (workItem);
+            return workItem.GetWorkItemResult ();
+        }
+
+        public IWorkItemResult QueueWorkItem<T1, T2>(Action<T1, T2> action, T1 arg1, T2 arg2)
+        {
+            return QueueWorkItem<T1, T2> (action, arg1, arg2, SmartThreadPool.DefaultWorkItemPriority);
+        }
+
+        public IWorkItemResult QueueWorkItem<T1, T2> (Action<T1, T2> action, T1 arg1, T2 arg2, WorkItemPriority priority)
+        {
+            PreQueueWorkItem ();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem (
+                this,
+                WIGStartInfo,
+                state =>
+                {
+                    action.Invoke (arg1, arg2);
+                    return null;
+                },
+                WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2 } : null, priority);
+            Enqueue (workItem);
+            return workItem.GetWorkItemResult ();
+        }
+
+        public IWorkItemResult QueueWorkItem<T1, T2, T3>(Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3)
+        {
+            return QueueWorkItem<T1, T2, T3> (action, arg1, arg2, arg3, SmartThreadPool.DefaultWorkItemPriority);
+            ;
+        }
+
+        public IWorkItemResult QueueWorkItem<T1, T2, T3> (Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3, WorkItemPriority priority)
+        {
+            PreQueueWorkItem ();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem (
+                this,
+                WIGStartInfo,
+                state =>
+                {
+                    action.Invoke (arg1, arg2, arg3);
+                    return null;
+                },
+                WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2, arg3 } : null, priority);
+            Enqueue (workItem);
+            return workItem.GetWorkItemResult ();
+        }
+
+        public IWorkItemResult QueueWorkItem<T1, T2, T3, T4>(
+            Action<T1, T2, T3, T4> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        {
+            return QueueWorkItem<T1, T2, T3, T4> (action, arg1, arg2, arg3, arg4,
+                                                  SmartThreadPool.DefaultWorkItemPriority);
+        }
+
+        public IWorkItemResult QueueWorkItem<T1, T2, T3, T4> (
+            Action<T1, T2, T3, T4> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, WorkItemPriority priority)
+        {
+            PreQueueWorkItem ();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem (
+                           this,
+                           WIGStartInfo,
+                           state =>
+                           {
+                               action.Invoke (arg1, arg2, arg3, arg4);
+                               return null;
+                           },
+                           WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2, arg3, arg4 } : null, priority);
+            Enqueue (workItem);
+            return workItem.GetWorkItemResult ();
+        }
+
+        #endregion
+
+        #region QueueWorkItem(Func<...>)
+
+        public IWorkItemResult<TResult> QueueWorkItem<TResult>(Func<TResult> func)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(
+                            this,
+                            WIGStartInfo,
+                            state =>
+                            {
+                                return func.Invoke();
+                            });
+            Enqueue(workItem);
+            return new WorkItemResultTWrapper<TResult>(workItem.GetWorkItemResult());
+        }
+
+        public IWorkItemResult<TResult> QueueWorkItem<T, TResult>(Func<T, TResult> func, T arg)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(
+                this,
+                WIGStartInfo,
+                state =>
+                {
+                    return func.Invoke(arg);
+                },
+                WIGStartInfo.FillStateWithArgs ? new object[] { arg } : null);
+            Enqueue(workItem);
+            return new WorkItemResultTWrapper<TResult>(workItem.GetWorkItemResult());
+        }
+
+        public IWorkItemResult<TResult> QueueWorkItem<T1, T2, TResult>(Func<T1, T2, TResult> func, T1 arg1, T2 arg2)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(
+                            this,
+                            WIGStartInfo,
+                            state =>
+                            {
+                                return func.Invoke(arg1, arg2);
+                            },
+                           WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2 } : null);
+            Enqueue(workItem);
+            return new WorkItemResultTWrapper<TResult>(workItem.GetWorkItemResult());
+        }
+
+        public IWorkItemResult<TResult> QueueWorkItem<T1, T2, T3, TResult>(
+            Func<T1, T2, T3, TResult> func, T1 arg1, T2 arg2, T3 arg3)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(
+                            this,
+                            WIGStartInfo,
+                            state =>
+                            {
+                                return func.Invoke(arg1, arg2, arg3);
+                            },
+                           WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2, arg3 } : null);
+            Enqueue(workItem);
+            return new WorkItemResultTWrapper<TResult>(workItem.GetWorkItemResult());
+        }
+
+        public IWorkItemResult<TResult> QueueWorkItem<T1, T2, T3, T4, TResult>(
+            Func<T1, T2, T3, T4, TResult> func, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(
+                            this,
+                            WIGStartInfo,
+                            state =>
+                            {
+                                return func.Invoke(arg1, arg2, arg3, arg4);
+                            },
+                           WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2, arg3, arg4 } : null);
+            Enqueue(workItem);
+            return new WorkItemResultTWrapper<TResult>(workItem.GetWorkItemResult());
+        }
+
+        #endregion
+
+        #endregion
+    }
+}
\ No newline at end of file
-- 
cgit v1.1


From 854dcd1abddc3eef33da953592deb61133e5e7ed Mon Sep 17 00:00:00 2001
From: Justin Clark-Casey (justincc)
Date: Wed, 1 May 2013 23:00:46 +0100
Subject: Fix SmartThreadPool line endings in recent update from dos to unix

---
 ThirdParty/SmartThreadPool/WorkItemsGroupBase.cs | 940 +++++++++++------------
 1 file changed, 470 insertions(+), 470 deletions(-)

(limited to 'ThirdParty/SmartThreadPool/WorkItemsGroupBase.cs')

diff --git a/ThirdParty/SmartThreadPool/WorkItemsGroupBase.cs b/ThirdParty/SmartThreadPool/WorkItemsGroupBase.cs
index 429de12..27fae5e 100644
--- a/ThirdParty/SmartThreadPool/WorkItemsGroupBase.cs
+++ b/ThirdParty/SmartThreadPool/WorkItemsGroupBase.cs
@@ -1,471 +1,471 @@
-using System;
-using System.Threading;
-
-namespace Amib.Threading.Internal
-{
-    public abstract class WorkItemsGroupBase : IWorkItemsGroup
-    {
-        #region Private Fields
-
-        /// <summary>
-        /// Contains the name of this instance of SmartThreadPool.
-        /// Can be changed by the user.
-        /// </summary>
-        private string _name = "WorkItemsGroupBase";
-
-        public WorkItemsGroupBase()
-        {
-            IsIdle = true;
-        }
-
-        #endregion
-
-        #region IWorkItemsGroup Members
-
-        #region Public Methods
-
-        /// <summary>
-        /// Get/Set the name of the SmartThreadPool/WorkItemsGroup instance
-        /// </summary>
-        public string Name
-        {
-            get { return _name; }
-            set { _name = value; }
-        }
-
-        #endregion
-
-        #region Abstract Methods
-
-        public abstract int Concurrency { get; set; }
-        public abstract int WaitingCallbacks { get; }
-        public abstract object[] GetStates();
-        public abstract WIGStartInfo WIGStartInfo { get; }
-        public abstract void Start();
-        public abstract void Cancel(bool abortExecution);
-        public abstract bool WaitForIdle(int millisecondsTimeout);
-        public abstract event WorkItemsGroupIdleHandler OnIdle;
-
-        internal abstract void Enqueue(WorkItem workItem);
-        internal virtual void PreQueueWorkItem() { }
-
-        #endregion
-
-        #region Common Base Methods
-
-        /// <summary>
-        /// Cancel all the work items.
-        /// Same as Cancel(false)
-        /// </summary>
-        public virtual void Cancel()
-        {
-            Cancel(false);
-        }
-
-        /// <summary>
-        /// Wait for the SmartThreadPool/WorkItemsGroup to be idle
-        /// </summary>
-        public void WaitForIdle()
-        {
-            WaitForIdle(Timeout.Infinite);
-        }
-
-        /// <summary>
-        /// Wait for the SmartThreadPool/WorkItemsGroup to be idle
-        /// </summary>
-        public bool WaitForIdle(TimeSpan timeout)
-        {
-            return WaitForIdle((int)timeout.TotalMilliseconds);
-        }
-
-        /// <summary>
-        /// IsIdle is true when there are no work items running or queued.
-        /// </summary>
-        public bool IsIdle { get; protected set; }
-
-        #endregion
-
-        #region QueueWorkItem
-
-        /// <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, WIGStartInfo, 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)
-        {
-            PreQueueWorkItem();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
-        {
-            PreQueueWorkItem();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
-        {
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
-        {
-            PreQueueWorkItem();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
-        {
-            PreQueueWorkItem();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
-        {
-            PreQueueWorkItem();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
-        {
-            PreQueueWorkItem();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
-        {
-            PreQueueWorkItem();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
-        {
-            PreQueueWorkItem();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, callback, state, postExecuteWorkItemCallback, callToPostExecute, workItemPriority);
-            Enqueue(workItem);
-            return workItem.GetWorkItemResult();
-        }
-
-        #endregion
-
-        #region QueueWorkItem(Action<...>)
-
-        public IWorkItemResult QueueWorkItem(Action action)
-        {
-            return QueueWorkItem (action, SmartThreadPool.DefaultWorkItemPriority);
-        }
-
-        public IWorkItemResult QueueWorkItem (Action action, WorkItemPriority priority)
-        {
-            PreQueueWorkItem ();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem (
-                this,
-                WIGStartInfo,
-                delegate
-                {
-                    action.Invoke ();
-                    return null;
-                }, priority);
-            Enqueue (workItem);
-            return workItem.GetWorkItemResult ();
-        }
-
-        public IWorkItemResult QueueWorkItem<T>(Action<T> action, T arg)
-        {
-            return QueueWorkItem<T> (action, arg, SmartThreadPool.DefaultWorkItemPriority);
-        }
-
-        public IWorkItemResult QueueWorkItem<T> (Action<T> action, T arg, WorkItemPriority priority)
-        {
-            PreQueueWorkItem ();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem (
-                this,
-                WIGStartInfo,
-                state =>
-                {
-                    action.Invoke (arg);
-                    return null;
-                },
-                WIGStartInfo.FillStateWithArgs ? new object[] { arg } : null, priority);
-            Enqueue (workItem);
-            return workItem.GetWorkItemResult ();
-        }
-
-        public IWorkItemResult QueueWorkItem<T1, T2>(Action<T1, T2> action, T1 arg1, T2 arg2)
-        {
-            return QueueWorkItem<T1, T2> (action, arg1, arg2, SmartThreadPool.DefaultWorkItemPriority);
-        }
-
-        public IWorkItemResult QueueWorkItem<T1, T2> (Action<T1, T2> action, T1 arg1, T2 arg2, WorkItemPriority priority)
-        {
-            PreQueueWorkItem ();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem (
-                this,
-                WIGStartInfo,
-                state =>
-                {
-                    action.Invoke (arg1, arg2);
-                    return null;
-                },
-                WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2 } : null, priority);
-            Enqueue (workItem);
-            return workItem.GetWorkItemResult ();
-        }
-
-        public IWorkItemResult QueueWorkItem<T1, T2, T3>(Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3)
-        {
-            return QueueWorkItem<T1, T2, T3> (action, arg1, arg2, arg3, SmartThreadPool.DefaultWorkItemPriority);
-            ;
-        }
-
-        public IWorkItemResult QueueWorkItem<T1, T2, T3> (Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3, WorkItemPriority priority)
-        {
-            PreQueueWorkItem ();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem (
-                this,
-                WIGStartInfo,
-                state =>
-                {
-                    action.Invoke (arg1, arg2, arg3);
-                    return null;
-                },
-                WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2, arg3 } : null, priority);
-            Enqueue (workItem);
-            return workItem.GetWorkItemResult ();
-        }
-
-        public IWorkItemResult QueueWorkItem<T1, T2, T3, T4>(
-            Action<T1, T2, T3, T4> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
-        {
-            return QueueWorkItem<T1, T2, T3, T4> (action, arg1, arg2, arg3, arg4,
-                                                  SmartThreadPool.DefaultWorkItemPriority);
-        }
-
-        public IWorkItemResult QueueWorkItem<T1, T2, T3, T4> (
-            Action<T1, T2, T3, T4> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, WorkItemPriority priority)
-        {
-            PreQueueWorkItem ();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem (
-                           this,
-                           WIGStartInfo,
-                           state =>
-                           {
-                               action.Invoke (arg1, arg2, arg3, arg4);
-                               return null;
-                           },
-                           WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2, arg3, arg4 } : null, priority);
-            Enqueue (workItem);
-            return workItem.GetWorkItemResult ();
-        }
-
-        #endregion
-
-        #region QueueWorkItem(Func<...>)
-
-        public IWorkItemResult<TResult> QueueWorkItem<TResult>(Func<TResult> func)
-        {
-            PreQueueWorkItem();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(
-                            this,
-                            WIGStartInfo,
-                            state =>
-                            {
-                                return func.Invoke();
-                            });
-            Enqueue(workItem);
-            return new WorkItemResultTWrapper<TResult>(workItem.GetWorkItemResult());
-        }
-
-        public IWorkItemResult<TResult> QueueWorkItem<T, TResult>(Func<T, TResult> func, T arg)
-        {
-            PreQueueWorkItem();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(
-                this,
-                WIGStartInfo,
-                state =>
-                {
-                    return func.Invoke(arg);
-                },
-                WIGStartInfo.FillStateWithArgs ? new object[] { arg } : null);
-            Enqueue(workItem);
-            return new WorkItemResultTWrapper<TResult>(workItem.GetWorkItemResult());
-        }
-
-        public IWorkItemResult<TResult> QueueWorkItem<T1, T2, TResult>(Func<T1, T2, TResult> func, T1 arg1, T2 arg2)
-        {
-            PreQueueWorkItem();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(
-                            this,
-                            WIGStartInfo,
-                            state =>
-                            {
-                                return func.Invoke(arg1, arg2);
-                            },
-                           WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2 } : null);
-            Enqueue(workItem);
-            return new WorkItemResultTWrapper<TResult>(workItem.GetWorkItemResult());
-        }
-
-        public IWorkItemResult<TResult> QueueWorkItem<T1, T2, T3, TResult>(
-            Func<T1, T2, T3, TResult> func, T1 arg1, T2 arg2, T3 arg3)
-        {
-            PreQueueWorkItem();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(
-                            this,
-                            WIGStartInfo,
-                            state =>
-                            {
-                                return func.Invoke(arg1, arg2, arg3);
-                            },
-                           WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2, arg3 } : null);
-            Enqueue(workItem);
-            return new WorkItemResultTWrapper<TResult>(workItem.GetWorkItemResult());
-        }
-
-        public IWorkItemResult<TResult> QueueWorkItem<T1, T2, T3, T4, TResult>(
-            Func<T1, T2, T3, T4, TResult> func, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
-        {
-            PreQueueWorkItem();
-            WorkItem workItem = WorkItemFactory.CreateWorkItem(
-                            this,
-                            WIGStartInfo,
-                            state =>
-                            {
-                                return func.Invoke(arg1, arg2, arg3, arg4);
-                            },
-                           WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2, arg3, arg4 } : null);
-            Enqueue(workItem);
-            return new WorkItemResultTWrapper<TResult>(workItem.GetWorkItemResult());
-        }
-
-        #endregion
-
-        #endregion
-    }
+using System;
+using System.Threading;
+
+namespace Amib.Threading.Internal
+{
+    public abstract class WorkItemsGroupBase : IWorkItemsGroup
+    {
+        #region Private Fields
+
+        /// <summary>
+        /// Contains the name of this instance of SmartThreadPool.
+        /// Can be changed by the user.
+        /// </summary>
+        private string _name = "WorkItemsGroupBase";
+
+        public WorkItemsGroupBase()
+        {
+            IsIdle = true;
+        }
+
+        #endregion
+
+        #region IWorkItemsGroup Members
+
+        #region Public Methods
+
+        /// <summary>
+        /// Get/Set the name of the SmartThreadPool/WorkItemsGroup instance
+        /// </summary>
+        public string Name
+        {
+            get { return _name; }
+            set { _name = value; }
+        }
+
+        #endregion
+
+        #region Abstract Methods
+
+        public abstract int Concurrency { get; set; }
+        public abstract int WaitingCallbacks { get; }
+        public abstract object[] GetStates();
+        public abstract WIGStartInfo WIGStartInfo { get; }
+        public abstract void Start();
+        public abstract void Cancel(bool abortExecution);
+        public abstract bool WaitForIdle(int millisecondsTimeout);
+        public abstract event WorkItemsGroupIdleHandler OnIdle;
+
+        internal abstract void Enqueue(WorkItem workItem);
+        internal virtual void PreQueueWorkItem() { }
+
+        #endregion
+
+        #region Common Base Methods
+
+        /// <summary>
+        /// Cancel all the work items.
+        /// Same as Cancel(false)
+        /// </summary>
+        public virtual void Cancel()
+        {
+            Cancel(false);
+        }
+
+        /// <summary>
+        /// Wait for the SmartThreadPool/WorkItemsGroup to be idle
+        /// </summary>
+        public void WaitForIdle()
+        {
+            WaitForIdle(Timeout.Infinite);
+        }
+
+        /// <summary>
+        /// Wait for the SmartThreadPool/WorkItemsGroup to be idle
+        /// </summary>
+        public bool WaitForIdle(TimeSpan timeout)
+        {
+            return WaitForIdle((int)timeout.TotalMilliseconds);
+        }
+
+        /// <summary>
+        /// IsIdle is true when there are no work items running or queued.
+        /// </summary>
+        public bool IsIdle { get; protected set; }
+
+        #endregion
+
+        #region QueueWorkItem
+
+        /// <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, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, 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)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(this, WIGStartInfo, callback, state, postExecuteWorkItemCallback, callToPostExecute, workItemPriority);
+            Enqueue(workItem);
+            return workItem.GetWorkItemResult();
+        }
+
+        #endregion
+
+        #region QueueWorkItem(Action<...>)
+
+        public IWorkItemResult QueueWorkItem(Action action)
+        {
+            return QueueWorkItem (action, SmartThreadPool.DefaultWorkItemPriority);
+        }
+
+        public IWorkItemResult QueueWorkItem (Action action, WorkItemPriority priority)
+        {
+            PreQueueWorkItem ();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem (
+                this,
+                WIGStartInfo,
+                delegate
+                {
+                    action.Invoke ();
+                    return null;
+                }, priority);
+            Enqueue (workItem);
+            return workItem.GetWorkItemResult ();
+        }
+
+        public IWorkItemResult QueueWorkItem<T>(Action<T> action, T arg)
+        {
+            return QueueWorkItem<T> (action, arg, SmartThreadPool.DefaultWorkItemPriority);
+        }
+
+        public IWorkItemResult QueueWorkItem<T> (Action<T> action, T arg, WorkItemPriority priority)
+        {
+            PreQueueWorkItem ();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem (
+                this,
+                WIGStartInfo,
+                state =>
+                {
+                    action.Invoke (arg);
+                    return null;
+                },
+                WIGStartInfo.FillStateWithArgs ? new object[] { arg } : null, priority);
+            Enqueue (workItem);
+            return workItem.GetWorkItemResult ();
+        }
+
+        public IWorkItemResult QueueWorkItem<T1, T2>(Action<T1, T2> action, T1 arg1, T2 arg2)
+        {
+            return QueueWorkItem<T1, T2> (action, arg1, arg2, SmartThreadPool.DefaultWorkItemPriority);
+        }
+
+        public IWorkItemResult QueueWorkItem<T1, T2> (Action<T1, T2> action, T1 arg1, T2 arg2, WorkItemPriority priority)
+        {
+            PreQueueWorkItem ();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem (
+                this,
+                WIGStartInfo,
+                state =>
+                {
+                    action.Invoke (arg1, arg2);
+                    return null;
+                },
+                WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2 } : null, priority);
+            Enqueue (workItem);
+            return workItem.GetWorkItemResult ();
+        }
+
+        public IWorkItemResult QueueWorkItem<T1, T2, T3>(Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3)
+        {
+            return QueueWorkItem<T1, T2, T3> (action, arg1, arg2, arg3, SmartThreadPool.DefaultWorkItemPriority);
+            ;
+        }
+
+        public IWorkItemResult QueueWorkItem<T1, T2, T3> (Action<T1, T2, T3> action, T1 arg1, T2 arg2, T3 arg3, WorkItemPriority priority)
+        {
+            PreQueueWorkItem ();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem (
+                this,
+                WIGStartInfo,
+                state =>
+                {
+                    action.Invoke (arg1, arg2, arg3);
+                    return null;
+                },
+                WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2, arg3 } : null, priority);
+            Enqueue (workItem);
+            return workItem.GetWorkItemResult ();
+        }
+
+        public IWorkItemResult QueueWorkItem<T1, T2, T3, T4>(
+            Action<T1, T2, T3, T4> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        {
+            return QueueWorkItem<T1, T2, T3, T4> (action, arg1, arg2, arg3, arg4,
+                                                  SmartThreadPool.DefaultWorkItemPriority);
+        }
+
+        public IWorkItemResult QueueWorkItem<T1, T2, T3, T4> (
+            Action<T1, T2, T3, T4> action, T1 arg1, T2 arg2, T3 arg3, T4 arg4, WorkItemPriority priority)
+        {
+            PreQueueWorkItem ();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem (
+                           this,
+                           WIGStartInfo,
+                           state =>
+                           {
+                               action.Invoke (arg1, arg2, arg3, arg4);
+                               return null;
+                           },
+                           WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2, arg3, arg4 } : null, priority);
+            Enqueue (workItem);
+            return workItem.GetWorkItemResult ();
+        }
+
+        #endregion
+
+        #region QueueWorkItem(Func<...>)
+
+        public IWorkItemResult<TResult> QueueWorkItem<TResult>(Func<TResult> func)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(
+                            this,
+                            WIGStartInfo,
+                            state =>
+                            {
+                                return func.Invoke();
+                            });
+            Enqueue(workItem);
+            return new WorkItemResultTWrapper<TResult>(workItem.GetWorkItemResult());
+        }
+
+        public IWorkItemResult<TResult> QueueWorkItem<T, TResult>(Func<T, TResult> func, T arg)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(
+                this,
+                WIGStartInfo,
+                state =>
+                {
+                    return func.Invoke(arg);
+                },
+                WIGStartInfo.FillStateWithArgs ? new object[] { arg } : null);
+            Enqueue(workItem);
+            return new WorkItemResultTWrapper<TResult>(workItem.GetWorkItemResult());
+        }
+
+        public IWorkItemResult<TResult> QueueWorkItem<T1, T2, TResult>(Func<T1, T2, TResult> func, T1 arg1, T2 arg2)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(
+                            this,
+                            WIGStartInfo,
+                            state =>
+                            {
+                                return func.Invoke(arg1, arg2);
+                            },
+                           WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2 } : null);
+            Enqueue(workItem);
+            return new WorkItemResultTWrapper<TResult>(workItem.GetWorkItemResult());
+        }
+
+        public IWorkItemResult<TResult> QueueWorkItem<T1, T2, T3, TResult>(
+            Func<T1, T2, T3, TResult> func, T1 arg1, T2 arg2, T3 arg3)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(
+                            this,
+                            WIGStartInfo,
+                            state =>
+                            {
+                                return func.Invoke(arg1, arg2, arg3);
+                            },
+                           WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2, arg3 } : null);
+            Enqueue(workItem);
+            return new WorkItemResultTWrapper<TResult>(workItem.GetWorkItemResult());
+        }
+
+        public IWorkItemResult<TResult> QueueWorkItem<T1, T2, T3, T4, TResult>(
+            Func<T1, T2, T3, T4, TResult> func, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        {
+            PreQueueWorkItem();
+            WorkItem workItem = WorkItemFactory.CreateWorkItem(
+                            this,
+                            WIGStartInfo,
+                            state =>
+                            {
+                                return func.Invoke(arg1, arg2, arg3, arg4);
+                            },
+                           WIGStartInfo.FillStateWithArgs ? new object[] { arg1, arg2, arg3, arg4 } : null);
+            Enqueue(workItem);
+            return new WorkItemResultTWrapper<TResult>(workItem.GetWorkItemResult());
+        }
+
+        #endregion
+
+        #endregion
+    }
 }
\ No newline at end of file
-- 
cgit v1.1