/// <summary>
/// Called when taskTimer elapsed.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.Timers.ElapsedEventArgs"/> instance containing the event data.</param>
private static void OnTaskTimerElapsed(object sender, System.Timers.ElapsedEventArgs e)
{
// get them out of the tasksInfos lists
if (taskResultInfos.Count > 0)
{
TaskResultInfo t = (TaskResultInfo)taskResultInfos.Dequeue();
//DispatchInvocationToGuiThread(new MethodInvocation(t.Task.ProgressHandler, new object[]{t.Task, t.Args}));
GuiInvoker.Invoke(null,
() => t.Task.ProgressHandler(t.Task, t.Args));
//t.Task.ProgressHandler(t.Task, t.Args);
}
// we do not start all waiting task thread at once:
if (!waitForGlobalThreadResource && taskStartInfos.Count > 0)
{
TaskStartInfo tInfo = (TaskStartInfo)taskStartInfos.Dequeue();
if (TaskStartInfo.StartMethod.ThreadStart == tInfo.ThreadStartMethod)
{
StartTask(tInfo.Task, tInfo.Action);
}
else if (TaskStartInfo.StartMethod.ThreadPool == tInfo.ThreadStartMethod)
{
QueueTask(tInfo.Task, tInfo.Action);
}
}
}
/// <summary>
/// Queue a task using a freshly created Thread.
/// </summary>
/// <param name="task">Task to start</param>
/// <param name="action">DuplicateTaskQueued</param>
/// <returns>True, if the task was successfully started, else false.</returns>
public static bool StartTask(ThreadWorkerTaskBase task, DuplicateTaskQueued action)
{
if (waitForGlobalThreadResource)
{
// delay startup of the thread
if (IsTaskWaitingForGlobalThreadResource(task.TaskID))
{
if (action == DuplicateTaskQueued.Ignore)
{
return(false);
}
if (action != DuplicateTaskQueued.Allowed)
{
return(false); // we do not have to wait/abort, they are not yet even started anyway
}
}
TaskStartInfo startInfo = new TaskStartInfo(TaskStartInfo.StartMethod.ThreadStart, task, action);
taskStartInfos.Enqueue(startInfo);
return(true);
}
if (IsTaskQueued(task.TaskID))
{
if (action == DuplicateTaskQueued.Ignore)
{
return(false);
}
if (action != DuplicateTaskQueued.Allowed) // wait, or abort running task thread
{
if (action == DuplicateTaskQueued.Abort)
{
AbortTask(task.TaskID);
}
if (action != DuplicateTaskQueued.Wait)
{
WaitForTask(task.TaskID);
}
}
}
ThreadWorkerBase wc = task.GetWorkerInstance();
Thread t = new Thread(new ThreadStart(wc.RunProcess));
t.IsBackground = true; //make them a daemon - prevent thread callback issues
task.WorkerThread = t;
t.Start();
queuedTasks.Add(task.TaskID, task);
return(true);
}
/// <summary>
/// Returns true, if a task is waiting to get queued for run
/// </summary>
/// <param name="task">Task</param>
/// <returns>bool</returns>
public static bool IsTaskWaitingForGlobalThreadResource(Enum task)
{
IEnumerator myEnumerator = taskStartInfos.GetEnumerator();
while (myEnumerator.MoveNext())
{
TaskStartInfo info = (TaskStartInfo)myEnumerator.Current;
if (info.Task.TaskID.Equals(task))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Queue a task using ThreadPool.
/// </summary>
/// <param name="task">Task to start</param>
/// <param name="action">Duplicate task action</param>
/// <returns>True, if the task was successfully queued up
/// to the ThreadPool, else false.</returns>
public static bool QueueTask(ThreadWorkerTaskBase task, DuplicateTaskQueued action)
{
if (waitForGlobalThreadResource)
{
// delay startup of the thread
if (IsTaskWaitingForGlobalThreadResource(task.TaskID))
{
if (action == DuplicateTaskQueued.Ignore)
{
return(false); // yet waiting
}
if (action != DuplicateTaskQueued.Allowed)
{
return(false); // we do not have to wait/abort, they are not yet even started anyway
}
}
TaskStartInfo startInfo = new TaskStartInfo(TaskStartInfo.StartMethod.ThreadPool, task, action);
taskStartInfos.Enqueue(startInfo);
return(true);
}
if (IsTaskQueued(task.TaskID))
{
if (action == DuplicateTaskQueued.Ignore)
{
return(false);
}
if (action != DuplicateTaskQueued.Allowed) // wait, or abort running task thread
{
if (action == DuplicateTaskQueued.Abort)
{
AbortTask(task.TaskID);
}
if (action != DuplicateTaskQueued.Wait)
{
WaitForTask(task.TaskID);
}
}
}
queuedTasks.Add(task.TaskID, task);
ThreadWorkerBase wc = task.GetWorkerInstance();
return(ThreadPool.QueueUserWorkItem(new WaitCallback(wc.RunProcess)));
}
