C# 4 and .NET 4

290 ❘ ChaPTer 11 lAnGuAGe inteGrAted Query
returns ParallelQuery. Because of the returned type, the Where() method that is chosen by
the compiler is ParallelEnumerable.Where() instead of Enumerable.Where(). In the following code, the
Select() and Sum() methods are from ParallelEnumerable as well. In contrast to the implementation of
the Enumerable class, with the ParallelEnumerable class the query is partitioned so that multiple threads
can work on the query. The array can be split into multiple parts where different threads work on every part
to filter the remaining items. After the partitioned work is completed, merging needs to take place to get the
summary result of all parts.
var sum = data.AsParallel().Where(x => x < 20).Select(x => x).Sum();
Running this code starts the task manager so you can see that all CPUs of your system are busy. If you
remove the AsParallel() method, multiple CPUs might not be used. Of course if you do not have multiple
CPUs on your system, then don’t expect to see an improvement with the parallel version.
Partitioners
The AsParallel() method is an extension not only to the IEnumerable interface, but also to the
Partitioner class. With this you can influence the partitions to be created.
The Partitioner class is defined with the namespace System.Collections.Concurrent and has different
variants. The Create() method accepts arrays or objects implementing IList. Depending on that, as
well as on the parameter loadBalance that is of type Boolean and available with some overloads of the
method, a different partitioner type is returned. For arrays, .NET 4 includes DynamicPartitionerFor
Array and StaticPartitionerForArray that both derive from the abstract base
class OrderablePartitioner.
The code from the “Parallel Queries” section is changed to manually create a partitioner instead of relying
on the default one:
var sum = (from x in Partitioner.Create(data, true).AsParallel()
where x < 20
select x).Sum();
You can also influence the parallelism by invoking the methods WithExecutionMode()
and WithDegreeOfParallelism(). With WithExecutionMode() you can pass a value of
ParallelExecutionMode that can be Default or ForceParallelism. By default, Parallel LINQ avoids
parallelism with high overheads. With the method WithDegreeOfParallelism() you can pass an integer
value to specify the maximum number of tasks that should run in parallel.
Cancellation
.NET 4 offers a standard way to cancel long-running tasks, and this is also true for Parallel LINQ.
To cancel a long-running query, you can add the method WithCancellation() to the query
and pass a CancellationToken to the parameter. The CancellationToken is created from the
CancellationTokenSource. The query is run in a separate thread where the exception of type
OperationCanceledException is caught. This exception is fired if the query is cancelled. From the main
thread the task can be cancelled by invoking the Cancel() method of the CancellationTokenSource.
var cts = new CancellationTokenSource();
new Thread(() =>
{
try
{
var sum = (from x in data.AsParallel().
WithCancellation(cts.Token)
where x < 80
select x).Sum();
Console.WriteLine("query finished, sum: {0}", sum);
www.it-ebooks.info