Task Factories in Visual Studio .NET

Creator Denso QR Bar Code in Visual Studio .NET Task Factories

Occasionally, you might want to create a bunch of Task objects that share the same state . To keep you from having to pass the same parameters to each Task s constructor over and over again, you can create a task factory that encapsulates the common state . The System.Threading.Tasks namespace defines a TaskFactory type as well as a TaskFactory<TResult> type . Both of these types are derived from System.Object; that is, they are peers of each other . If you want to create a bunch of tasks that have no return values, then you will construct a TaskFactory . If you want to create a bunch of tasks that have a specific return value, then you will construct a TaskFactory<TResult> where you pass the task s desired return type for the generic TResult argument . When you create one of these task factory classes, you pass to its constructor the defaults that you want the tasks that the factory creates to

have . Specifically, you pass to the task factory the CancellationToken, TaskScheduler, TaskCreationOptions, and TaskContinuationOptions settings that you want factorycreated tasks to have . Here is some sample code demonstrating the use of a TaskFactory:

Task parent = new Task(() => { varcts = new CancellationTokenSource(); vartf = new TaskFactory<Int32>(cts.Token, TaskCreationOptions.AttachedToParent, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default); // This tasks creates and starts varchildTasks = new[] { tf.StartNew(() => Sum(cts.Token, tf.StartNew(() => Sum(cts.Token, tf.StartNew(() => Sum(cts.Token, }; 3 child tasks 10000)), 20000)), Int32.MaxValue))

// If any of the child tasks throw, cancel the rest of them for (Int32 task = 0; task <childTasks.Length; task++) childTasks[task].ContinueWith( t => cts.Cancel(), TaskContinuationOptions.OnlyOnFaulted); // When all children are done, get the maximum value returned from the // non-faulting/canceled tasks. Then pass the maximum value to another // task which displays the maximum result tf.ContinueWhenAll( childTasks, completedTasks => completedTasks.Where( t => !t.IsFaulted && !t.IsCanceled).Max(t => t.Result), CancellationToken.None) .ContinueWith(t =>Console.WriteLine("The maximum is: " + t.Result), TaskContinuationOptions.ExecuteSynchronously); });

// When the children are done, show any unhandled exceptions too parent.ContinueWith(p => { // I put all this text in a StringBuilder and call Console.WriteLine just once // because this task could execute concurrently with the task above & I don't // want the tasks' output interspersed StringBuildersb = new StringBuilder( "The following exception(s) occurred:" + Environment.NewLine); foreach (var e in p.Exception.Flatten().InnerExceptions) sb.AppendLine(" "+ e.GetType().ToString()); Console.WriteLine(sb.ToString()); }, TaskContinuationOptions.OnlyOnFaulted); // Start the parent Task so it can start its children parent.Start();

26

With this code, I am creating a TaskFactory<Int32> object that I will use to create three Task objects . I want four things: for each Task object to share the same CancellationTokenSource token, for all three tasks to be considered children of their parent, for all continue-with tasks created by the TaskFactory object to execute synchronously, and for all the Task objects created by this TaskFactory to use the default TaskScheduler . Then I create an array consisting of the three child Task objects, all created by calling TaskFactory s StartNew method . This method conveniently creates and starts each child task . In a loop, I tell each child task that throws an unhandled exception to cancel all the other child tasks that are still running . Finally, using the TaskFactory, I call ContinueWhenAll, which creates a Task that runs when all the child tasks have completed running . Since this task is created with the TaskFactory, it will also be considered a child of the parent task and it will execute synchronously using the default TaskScheduler . However, I want this task to run even if the other child tasks were canceled, so I override the TaskFactory s CancellationToken by passing in CancellationToken.None, which prevents this task from being cancelable at all . Finally, when the task that processes all the results is complete, I create another task that displays the highest value returned from all the child tasks . Note When calling TaskFactory s or TaskFactory<TResult> s static ContinueWhenAll

and ContinueWhenAny methods, the following TaskContinuationOption flags are illegal: NotOnRanToCompletion, NotOnFaulted, and NotOnCanceled . And of course, the convenience flags (OnlyOnCanceled, OnlyOnFaulted, and OnlyOnRanToCompletion) are also illegal . That is, ContinueWhenAll and ContinueWhenAny execute the continue-with task regardless of how the antecedent tasks complete .