/// <summary>
/// Creates and schedules a task to execute the given work with the given work data.
/// </summary>
/// <param name="action">The work to execute in parallel.</param>
/// <param name="completionCallback">A method which will be called in Parallel.RunCallbacks() once this task has completed.</param>
/// <param name="workData">Data to be passed along both the work and the completion callback.</param>
/// <returns>A task which represents one execution of the action.</returns>
public static Task Start(Action <WorkData> action, Action <WorkData> completionCallback, WorkData workData)
{
WorkOptions options = new WorkOptions()
{
MaximumThreads = 1, DetachFromParent = false, QueueFIFO = false
};
var work = DelegateWork.GetInstance();
work.DataAction = action;
work.Options = options;
var workItem = WorkItem.Get(Thread.CurrentThread);
workItem.CompletionCallbacks = CallbackBuffer;
workItem.DataCallback = completionCallback;
if (workData != null)
{
workItem.WorkData = workData;
workData.WorkState = WorkData.WorkStateEnum.NOT_STARTED;
}
else
{
workItem.WorkData = new WorkData();
}
var task = workItem.PrepareStart(work);
Scheduler.Schedule(task);
return(task);
}
public ForLoopWork()
{
Options = new WorkOptions()
{
MaximumThreads = int.MaxValue
};
}
public ForEachLoopWork()
{
Options = new WorkOptions()
{
MaximumThreads = int.MaxValue
};
syncLock = new object();
}
/// <summary>
/// Creates and starts a task to execute the given work.
/// </summary>
/// <param name="action">The work to execute in parallel.</param>
/// <param name="options">The work options to use with this action.</param>
/// <param name="completionCallback">A method which will be called in Parallel.RunCallbacks() once this task has completed.</param>
/// <returns>A task which represents one execution of the work.</returns>
public static Task Start(Action action, WorkOptions options, Action completionCallback)
{
if (options.MaximumThreads < 1)
{
throw new ArgumentOutOfRangeException("options", "options.MaximumThreads cannot be less than 1.");
}
var work = DelegateWork.GetInstance();
work.Action = action;
work.Options = options;
return(Start(work, completionCallback));
}
/// <summary>
/// Creates and starts a task which executes the given function and stores the result for later retrieval.
/// </summary>
/// <typeparam name="T">The type of result the function returns.</typeparam>
/// <param name="function">The function to execute in parallel.</param>
/// <param name="options">The work options to use with this action.</param>
/// <param name="completionCallback">A method which will be called in Parallel.RunCallbacks() once this task has completed.</param>
/// <returns>A future which represents one execution of the function.</returns>
public static Future <T> Start <T>(Func <T> function, WorkOptions options, Action completionCallback)
{
if (options.MaximumThreads < 1)
{
throw new ArgumentOutOfRangeException("options", "options.MaximumThreads cannot be less than 1.");
}
var work = FutureWork <T> .GetInstance();
work.Function = function;
work.Options = options;
var task = Start(work, completionCallback);
return(new Future <T>(task, work));
}
/// <summary>
/// Creates and schedules a task to execute on the given work-tracking thread.
/// If the requested thread that does not execute completion callbacks the callback will never be called.
/// </summary>
/// <param name="action">The work to execute in parallel.</param>
/// <param name="workData">Data to be passed along both the work and the completion callback.</param>
/// <param name="thread">Thread to execute the callback on. If not provided this is the calling thread.</param>
/// <returns>A task which represents one execution of the action.</returns>
public static Task ScheduleForThread(Action <WorkData> action, WorkData workData, Thread thread = null)
{
if (thread == null)
{
thread = Thread.CurrentThread;
}
WorkOptions options = new WorkOptions()
{
MaximumThreads = 1, DetachFromParent = false, QueueFIFO = false
};
var work = DelegateWork.GetInstance();
work.Options = options;
var workItem = WorkItem.Get(thread);
lock (Buffers)
{
workItem.CompletionCallbacks = Buffers[thread];
}
workItem.DataCallback = action;
if (workData != null)
{
workItem.WorkData = workData;
}
else
{
workItem.WorkData = new WorkData();
}
var task = workItem.PrepareStart(work, thread);
CallbackBuffer.Add(workItem);
return(task);
}
public ActionWork(Action <WorkData> action, WorkOptions options)
{
this.Action = action;
this.Options = options;
}
/// <summary>
/// Creates and starts a task which executes the given function and stores the result for later retrieval.
/// </summary>
/// <typeparam name="T">The type of result the function returns.</typeparam>
/// <param name="function">The function to execute in parallel.</param>
/// <param name="options">The work options to use with this action.</param>
/// <returns>A future which represents one execution of the function.</returns>
public static Future <T> Start <T>(Func <T> function, WorkOptions options)
{
return(Start <T>(function, options, null));
}
/// <summary>
/// Creates and starts a task to execute the given work.
/// </summary>
/// <param name="action">The work to execute in parallel.</param>
/// <param name="options">The work options to use with this action.</param>
/// <returns>A task which represents one execution of the work.</returns>
public static Task Start(Action action, WorkOptions options)
{
return(Start(action, options, null));
}
public ActionWork(Action<WorkData> action, WorkOptions options)
{
this._Action = action;
this.Options = options;
}
public ActionWork(Action action, WorkOptions options)
{
this.Action = action;
this.Options = options;
}
