/// <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; }