PowerPool

Properties

PowerPoolOption

PowerPoolOption PowerPoolOption;

Indicates whether to perform pool idle check

bool EnablePoolIdleCheck;

[Get only]
Thread pool is running or not

bool PoolRunning;

[Get only]
Thread pool is stopping (when user call Stop(...)) or not.
When thread pool idled, PoolStopping becomes false.

bool PoolStopping;

[Get only]
Idle worker count

int IdleWorkerCount;

[Get only]
Waiting work count

int WaitingWorkCount;

[Get only]
ID list of waiting works

IEnumerable<WorkID> WaitingWorkList;

[Get only]
Failed work count
Will be reset to zero when the thread pool starts again

int FailedWorkCount;

[Get only]
ID list of failed works
Will be cleared when the thread pool starts again

IEnumerable<WorkID> FailedWorkList;

[Get only]
Running worker count

int RunningWorkerCount;

[Get only]
Alive worker count

int AliveWorkerCount;

[Get only]
Long running worker count

int LongRunningWorkerCount;

[Get only]
The total time spent in the queue (ms).
Will be reset when the thread pool starts again.

long TotalQueueTime;

[Get only]
The total time taken for execution (ms).
Will be reset when the thread pool starts again.

long TotalExecuteTime;

[Get only]
The average time spent in the queue (ms).
Will be reset when the thread pool starts again.

long AverageQueueTime;

[Get only]
The average time taken for execution (ms).
Will be reset when the thread pool starts again.

long AverageExecuteTime;

[Get only]
The average elapsed time from start queue to finish (ms).
Will be reset when the thread pool starts again.

long AverageElapsedTime;

[Get only]
The total elapsed time from start queue to finish (ms).
Will be reset when the thread pool starts again.

long TotalElapsedTime;

[Get only]
Pool runtime duration.
Will be reset when the thread pool starts again.

TimeSpan RuntimeDuration;

Events

event EventHandler<EventArgs> PoolStarted;

event EventHandler<PoolIdledEventArgs> PoolIdled;

event EventHandler<RunningWorkerCountChangedEventArgs> RunningWorkerCountChanged;

event EventHandler<WorkStartedEventArgs> WorkStarted;

event EventHandler<WorkEndedEventArgs> WorkEnded;

event EventHandler<EventArgs>PoolTimedOut;

event EventHandler<WorkTimedOutEventArgs>WorkTimedOut;

event EventHandler<WorkStoppedEventArgs> WorkStopped;

event EventHandler<WorkCanceledEventArgs> WorkCanceled;

event EventHandler<ErrorOccurredEventArgs> ErrorOccurred;

Methods

Read the API Summary here.

QueueWorkItem (Sync work)

WorkID QueueWorkItem<T1>(Action<T1> action, T1 param1, Action<ExecuteResult<object>> callBack = null);
WorkID QueueWorkItem<T1>(Action<T1> action, T1 param1, WorkOption option);
WorkID QueueWorkItem<T1, T2>(Action<T1, T2> action, T1 param1, T2 param2, Action<ExecuteResult<object>> callBack = null);
WorkID QueueWorkItem<T1, T2>(Action<T1, T2> action, T1 param1, T2 param2, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3>(Action<T1, T2, T3> action, T1 param1, T2 param2, T3 param3, Action<ExecuteResult<object>> callBack = null);
WorkID QueueWorkItem<T1, T2, T3>(Action<T1, T2, T3> action, T1 param1, T2 param2, T3 param3, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action, T1 param1, T2 param2, T3 param3, T4 param4, Action<ExecuteResult<object>> callBack = null);
WorkID QueueWorkItem<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action, T1 param1, T2 param2, T3 param3, T4 param4, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3, T4, T5>(Action<T1, T2, T3, T4, T5> action, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, Action<ExecuteResult<object>> callBack = null);
WorkID QueueWorkItem<T1, T2, T3, T4, T5>(Action<T1, T2, T3, T4, T5> action, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, WorkOption option);
WorkID QueueWorkItem(Action action, Action<ExecuteResult<object>> callBack = null);
WorkID QueueWorkItem(Action action, WorkOption option);
WorkID QueueWorkItem(Action<object[]> action, object[] param, Action<ExecuteResult<object>> callBack = null);
WorkID QueueWorkItem(Action<object[]> action, object[] param, WorkOption option);
WorkID QueueWorkItem<T1, TResult>(Func<T1, TResult> function, T1 param1, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<T1, TResult>(Func<T1, TResult> function, T1 param1, WorkOption option);
WorkID QueueWorkItem<T1, T2, TResult>(Func<T1, T2, TResult> function, T1 param1, T2 param2, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<T1, T2, TResult>(Func<T1, T2, TResult> function, T1 param1, T2 param2, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3, TResult>(Func<T1, T2, T3, TResult> function, T1 param1, T2 param2, T3 param3, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<T1, T2, T3, TResult>(Func<T1, T2, T3, TResult> function, T1 param1, T2 param2, T3 param3, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, TResult> function, T1 param1, T2 param2, T3 param3, T4 param4, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, TResult> function, T1 param1, T2 param2, T3 param3, T4 param4, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3, T4, T5, TResult>(Func<T1, T2, T3, T4, T5, TResult> function, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<T1, T2, T3, T4, T5, TResult>(Func<T1, T2, T3, T4, T5, TResult> function, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, WorkOption option);
WorkID QueueWorkItem<TResult>(Func<TResult> function, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<TResult>(Func<TResult> function, WorkOption option);
WorkID QueueWorkItem<TResult>(Func<object[], TResult> function, object[] param, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<TResult>(Func<object[], TResult> function, object[] param, WorkOption option);

QueueWorkItem (Async work)

WorkID QueueWorkItem(Func<Task> asyncFunc, Action<ExecuteResultBase> callBack = null);
WorkID QueueWorkItem(Func<Task> asyncFunc, WorkOption option);
WorkID QueueWorkItem(Func<object[], Task> asyncFunc, object[] param, Action<ExecuteResultBase> callBack = null);
WorkID QueueWorkItem(Func<object[], Task> asyncFunc, object[] param, WorkOption option);
WorkID QueueWorkItem<T1>(Func<T1, Task> asyncFunc, T1 param1, Action<ExecuteResultBase> callBack = null);
WorkID QueueWorkItem<T1>(Func<T1, Task> asyncFunc, T1 param1, WorkOption option);
WorkID QueueWorkItem<T1, T2>(Func<T1, T2, Task> asyncFunc, T1 param1, T2 param2, Action<ExecuteResultBase> callBack = null);
WorkID QueueWorkItem<T1, T2>(Func<T1, T2, Task> asyncFunc, T1 param1, T2 param2, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3>(Func<T1, T2, T3, Task> asyncFunc, T1 param1, T2 param2, T3 param3, Action<ExecuteResultBase> callBack = null);
WorkID QueueWorkItem<T1, T2, T3>(Func<T1, T2, T3, Task> asyncFunc, T1 param1, T2 param2, T3 param3, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3, T4>(Func<T1, T2, T3, T4, Task> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, Action<ExecuteResultBase> callBack = null);
WorkID QueueWorkItem<T1, T2, T3, T4>(Func<T1, T2, T3, T4, Task> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3, T4, T5>(Func<T1, T2, T3, T4, T5, Task> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, Action<ExecuteResultBase> callBack = null);
WorkID QueueWorkItem<T1, T2, T3, T4, T5>(Func<T1, T2, T3, T4, T5, Task> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, WorkOption option);
WorkID QueueWorkItem<TResult>(Func<Task<TResult>> asyncFunc, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<TResult>(Func<Task<TResult>> asyncFunc, WorkOption option);
WorkID QueueWorkItem<TResult>(Func<object[], Task<TResult>> asyncFunc, object[] param, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<TResult>(Func<object[], Task<TResult>> asyncFunc, object[] param, WorkOption option);
WorkID QueueWorkItem<T1, TResult>(Func<T1, Task<TResult>> asyncFunc, T1 param1, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<T1, TResult>(Func<T1, Task<TResult>> asyncFunc, T1 param1, WorkOption option);
WorkID QueueWorkItem<T1, T2, TResult>(Func<T1, T2, Task<TResult>> asyncFunc, T1 param1, T2 param2, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<T1, T2, TResult>(Func<T1, T2, Task<TResult>> asyncFunc, T1 param1, T2 param2, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3, TResult>(Func<T1, T2, T3, Task<TResult>> asyncFunc, T1 param1, T2 param2, T3 param3, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<T1, T2, T3, TResult>(Func<T1, T2, T3, Task<TResult>> asyncFunc, T1 param1, T2 param2, T3 param3, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, Task<TResult>> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, Task<TResult>> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3, T4, T5, TResult>(Func<T1, T2, T3, T4, T5, Task<TResult>> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<T1, T2, T3, T4, T5, TResult>(Func<T1, T2, T3, T4, T5, Task<TResult>> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, WorkOption option);
WorkID QueueWorkItem(Func<Task> asyncFunc, out Task task, Action<ExecuteResultBase> callBack = null);
WorkID QueueWorkItem(Func<Task> asyncFunc, out Task task, WorkOption option);
WorkID QueueWorkItem(Func<object[], Task> asyncFunc, object[] param, out Task task, Action<ExecuteResultBase> callBack = null);
WorkID QueueWorkItem(Func<object[], Task> asyncFunc, object[] param, out Task task, WorkOption option);
WorkID QueueWorkItem<T1>(Func<T1, Task> asyncFunc, T1 param1, out Task task, Action<ExecuteResultBase> callBack = null);
WorkID QueueWorkItem<T1>(Func<T1, Task> asyncFunc, T1 param1, out Task task, WorkOption option);
WorkID QueueWorkItem<T1, T2>(Func<T1, T2, Task> asyncFunc, T1 param1, T2 param2, out Task task, Action<ExecuteResultBase> callBack = null);
WorkID QueueWorkItem<T1, T2>(Func<T1, T2, Task> asyncFunc, T1 param1, T2 param2, out Task task, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3>(Func<T1, T2, T3, Task> asyncFunc, T1 param1, T2 param2, T3 param3, out Task task, Action<ExecuteResultBase> callBack = null);
WorkID QueueWorkItem<T1, T2, T3>(Func<T1, T2, T3, Task> asyncFunc, T1 param1, T2 param2, T3 param3, out Task task, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3, T4>(Func<T1, T2, T3, T4, Task> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, out Task task, Action<ExecuteResultBase> callBack = null);
WorkID QueueWorkItem<T1, T2, T3, T4>(Func<T1, T2, T3, T4, Task> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, out Task task, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3, T4, T5>(Func<T1, T2, T3, T4, T5, Task> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, out Task task, Action<ExecuteResultBase> callBack = null);
WorkID QueueWorkItem<T1, T2, T3, T4, T5>(Func<T1, T2, T3, T4, T5, Task> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, out Task task, WorkOption option);
WorkID QueueWorkItem<TResult>(Func<Task<TResult>> asyncFunc, out Task<ExecuteResult<TResult>> task, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<TResult>(Func<Task<TResult>> asyncFunc, out Task<ExecuteResult<TResult>> task, WorkOption option);
WorkID QueueWorkItem<TResult>(Func<object[], Task<TResult>> asyncFunc, object[] param, out Task<ExecuteResult<TResult>> task, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<TResult>(Func<object[], Task<TResult>> asyncFunc, object[] param, out Task<ExecuteResult<TResult>> task, WorkOption option);
WorkID QueueWorkItem<T1, TResult>(Func<T1, Task<TResult>> asyncFunc, T1 param1, out Task<ExecuteResult<TResult>> task, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<T1, TResult>(Func<T1, Task<TResult>> asyncFunc, T1 param1, out Task<ExecuteResult<TResult>> task, WorkOption option);
WorkID QueueWorkItem<T1, T2, TResult>(Func<T1, T2, Task<TResult>> asyncFunc, T1 param1, T2 param2, out Task<ExecuteResult<TResult>> task, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<T1, T2, TResult>(Func<T1, T2, Task<TResult>> asyncFunc, T1 param1, T2 param2, out Task<ExecuteResult<TResult>> task, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3, TResult>(Func<T1, T2, T3, Task<TResult>> asyncFunc, T1 param1, T2 param2, T3 param3, out Task<ExecuteResult<TResult>> task, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<T1, T2, T3, TResult>(Func<T1, T2, T3, Task<TResult>> asyncFunc, T1 param1, T2 param2, T3 param3, out Task<ExecuteResult<TResult>> task, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, Task<TResult>> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, out Task<ExecuteResult<TResult>> task, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, Task<TResult>> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, out Task<ExecuteResult<TResult>> task, WorkOption option);
WorkID QueueWorkItem<T1, T2, T3, T4, T5, TResult>(Func<T1, T2, T3, T4, T5, Task<TResult>> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, out Task<ExecuteResult<TResult>> task, Action<ExecuteResult<TResult>> callBack = null);
WorkID QueueWorkItem<T1, T2, T3, T4, T5, TResult>(Func<T1, T2, T3, T4, T5, Task<TResult>> asyncFunc, T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, out Task<ExecuteResult<TResult>> task, WorkOption option);

Control

void PauseIfRequested();
void StopIfRequested(Func<bool> beforeStop = null);
bool CheckIfRequestedStop();
void Wait(bool helpWhileWaiting = false);
void Wait(CancellationToken cancellationToken, bool helpWhileWaiting = false);
bool Wait(WorkID id, bool helpWhileWaiting = false);
bool Wait(WorkID id, CancellationToken cancellationToken, bool helpWhileWaiting = false);
List<WorkID> Wait(IEnumerable<WorkID> idList, bool helpWhileWaiting = false);
List<WorkID> Wait(IEnumerable<WorkID> idList, CancellationToken cancellationToken, bool helpWhileWaiting = false);
async Task WaitAsync();
async Task WaitAsync(CancellationToken cancellationToken);
async Task<bool> WaitAsync(WorkID id);
async Task<bool> WaitAsync(WorkID id, CancellationToken cancellationToken);
async Task<List<WorkID>> WaitAsync(IEnumerable<WorkID> idList);
async Task<List<WorkID>> WaitAsync(IEnumerable<WorkID> idList, CancellationToken cancellationToken);
ExecuteResult<TResult> Fetch<TResult>(WorkID id, bool removeAfterFetch = false, bool helpWhileWaiting = false);
ExecuteResult<TResult> Fetch<TResult>(WorkID id, CancellationToken cancellationToken, bool removeAfterFetch = false, bool helpWhileWaiting = false);
ExecuteResult<object> Fetch(WorkID id, bool removeAfterFetch = false, bool helpWhileWaiting = false);
ExecuteResult<object> Fetch(WorkID id, CancellationToken cancellationToken, bool removeAfterFetch = false, bool helpWhileWaiting = false);
List<ExecuteResult<TResult>> Fetch<TResult>(IEnumerable<WorkID> idList, bool removeAfterFetch = false, bool helpWhileWaiting = false);
List<ExecuteResult<TResult>> Fetch<TResult>(IEnumerable<WorkID> idList, CancellationToken cancellationToken, bool removeAfterFetch = false, bool helpWhileWaiting = false);
List<ExecuteResult<object>> Fetch(IEnumerable<WorkID> idList, bool removeAfterFetch = false, bool helpWhileWaiting = false);
List<ExecuteResult<object>> Fetch(IEnumerable<WorkID> idList, CancellationToken cancellationToken, bool removeAfterFetch = false, bool helpWhileWaiting = false);
List<ExecuteResult<TResult>> Fetch<TResult>(Func<ExecuteResult<TResult>, bool> predicate, bool removeAfterFetch = false, bool helpWhileWaiting = false);
async Task<ExecuteResult<TResult>> FetchAsync<TResult>(WorkID id, bool removeAfterFetch = false);
async Task<ExecuteResult<TResult>> FetchAsync<TResult>(WorkID id, CancellationToken cancellationToken, bool removeAfterFetch = false);
async Task<ExecuteResult<object>> FetchAsync(WorkID id, bool removeAfterFetch = false);
async Task<ExecuteResult<object>> FetchAsync(WorkID id, CancellationToken cancellationToken, bool removeAfterFetch = false);
async Task<List<ExecuteResult<TResult>>> FetchAsync<TResult>(IEnumerable<WorkID> idList, bool removeAfterFetch = false);
async Task<List<ExecuteResult<TResult>>> FetchAsync<TResult>(IEnumerable<WorkID> idList, CancellationToken cancellationToken, bool removeAfterFetch = false);
async Task<List<ExecuteResult<object>>> FetchAsync(IEnumerable<WorkID> idList, bool removeAfterFetch = false);
async Task<List<ExecuteResult<object>>> FetchAsync(IEnumerable<WorkID> idList, CancellationToken cancellationToken, bool removeAfterFetch = false);
bool Stop();
bool ForceStop();
bool Stop(WorkID id);
bool ForceStop(WorkID id);
List<WorkID> Stop(IEnumerable<WorkID> idList);
List<WorkID> ForceStop(IEnumerable<WorkID> idList);
void Pause();
bool Pause(WorkID id);
List<WorkID> Pause(IEnumerable<WorkID> idList);
void Resume(bool resumeWorkPausedByID = false);
bool Resume(WorkIDid);
List<WorkID> Resume(IEnumerable<WorkID> idList);
void Cancel();
bool Cancel(WorkIDid);
List<WorkID> Cancel(IEnumerable<WorkID> idList);

Group

Group GetGroup(string groupName);
ConcurrentSet<WorkID> GetGroupMemberSet(string groupName);
bool AddWorkToGroup(string groupName, WorkID workID);
bool RemoveWorkFromGroup(string groupName, WorkID workID);
void SetGroupRelation(string parentGroup, string childGroup);
bool RemoveGroupRelation(string parentGroup, string childGroup = null);
void ResetGroupRelation();

Parallel

Group For(int start, int end, Action<int> body, int step = 1, string groupName = null);
Group For(int start, int end, Func<int, Task> body, int step = 1, string groupName = null)
Group For<TSource>(int start, int end, IList<TSource> source, Action<TSource> body, int step = 1, string groupName = null);
Group For<TSource>(int start, int end, IList<TSource> source, Func<TSource, Task> body, int step = 1, string groupName = null)
Group For<TSource>(int start, int end, IList<TSource> source, Action<TSource, int> body, int step = 1, string groupName = null);
Group For<TSource>(int start, int end, IList<TSource> source, Func<TSource, int, Task> body, int step = 1, string groupName = null)
Group ForEach<TSource>(IEnumerable<TSource> source, Action<TSource> body, string groupName = null);
Group ForEach<TSource>(IEnumerable<TSource> source, Func<TSource, Task> body, string groupName = null)
Group ForEach<TSource>(IEnumerable<TSource> source, Action<TSource, int> body, string groupName = null);
Group ForEach<TSource>(IEnumerable<TSource> source, Func<TSource, int, Task> body, string groupName = null)
Group Watch<TSource>(ConcurrentObservableCollection<TSource> source, Action<TSource> body, bool addBackWhenWorkCanceled = true, bool addBackWhenWorkStopped = true, bool addBackWhenWorkFailed = true, string groupName = null)
Group Watch<TSource>(ConcurrentObservableCollection<TSource> source, Func<TSource, Task> body, bool addBackWhenWorkCanceled = true, bool addBackWhenWorkStopped = true, bool addBackWhenWorkFailed = true, string groupName = null)

Other

void Start();
void ClearResultStorage();
void ClearResultStorage(WorkID workID);
void ClearResultStorage(IEnumerable<WorkID> workIDList);
void ClearFailedWorkRecord();
void Dispose();