/// <summary>
/// Processes the next available tasks and returns true when it has been processed and false otherwise.
/// This method will block until th exitHandle has been set or a task should be processed.
/// Only call this inside the thread you want the tasks to process to be processed.
/// </summary>
/// <param name="exitHandle">The handle to indicate an early abort of the wait process.</param>
/// <returns>False when the exitHandle has been set, true otherwise.</returns>
public bool ProcessNextTask(WaitHandle exitHandle)
{
var result = WaitHandle.WaitAny(new [] { exitHandle, DataEvent });
if (result == 0)
{
return(false);
}
CustomTask task;
lock (TaskListSyncRoot)
{
if (TaskList.Count == 0)
{
return(false);
}
task = TaskList.Dequeue();
}
ProcessSingleTask(task);
if (TaskCount == 0)
{
DataEvent.Reset();
}
return(true);
}
/// <summary>
/// Processes the next available tasks and returns true when it has been processed and false otherwise.
/// This method will block until th exitHandle has been set or a task should be processed.
/// Only call this inside the thread you want the tasks to process to be processed.
/// </summary>
/// <param name="exitHandle">The handle to indicate an early abort of the wait process.</param>
/// <returns>False when the exitHandle has been set, true otherwise.</returns>
public bool ProcessNextTask(WaitHandle exitHandle)
{
var result = WaitHandle.WaitAny(new[] { exitHandle, DataEvent });
if (result == 0)
{
return(false);
}
lock (TaskList)
ProcessSingleTask();
if (TaskCount == 0)
{
DataEvent.Reset();
}
return(true);
}
/// <summary>
/// Processed the next available task.
/// Only call this inside the thread you want the tasks to process to be processed.
/// </summary>
/// <returns>True when a task to process has been processed, false otherwise.</returns>
public bool ProcessNextTask()
{
lock (TaskList)
{
if (TaskList.Count == 0)
{
return(false);
}
ProcessSingleTask();
}
if (TaskCount == 0)
{
DataEvent.Reset();
}
return(true);
}
private void ProcessTasksInternal()
{
List <CustomTask> tmpCopy;
lock (TaskListSyncRoot)
{
tmpCopy = new List <CustomTask>(TaskList);
TaskList.Clear();
}
while (tmpCopy.Count != 0)
{
var task = tmpCopy[0];
tmpCopy.RemoveAt(0);
ProcessSingleTask(task);
}
if (TaskCount == 0)
{
DataEvent.Reset();
}
}
/// <summary>
/// Processed the next available task.
/// Only call this inside the thread you want the tasks to process to be processed.
/// </summary>
/// <returns>True when a task to process has been processed, false otherwise.</returns>
public bool ProcessNextTask()
{
CustomTask task;
lock (TaskListSyncRoot)
{
if (TaskList.Count == 0)
{
return(false);
}
task = TaskList.Dequeue();
}
ProcessSingleTask(task);
if (TaskCount == 0)
{
DataEvent.Reset();
}
return(true);
}
private void ProcessTasksInternal()
{
lock (TaskList)
{
float accum = 0;
while (TaskList.Count != 0)
{
//If we have taken more than 33ms to run all tasks, return and wait for
//the next frame to run more tasks.
if (accum >= (1f / FPSTarget))
{
return;
}
float s = Time.realtimeSinceStartup;
ProcessSingleTask();
accum += Time.realtimeSinceStartup - s;
}
}
if (TaskCount == 0)
{
DataEvent.Reset();
}
}