{"id":1176,"date":"2023-03-27T10:01:39","date_gmt":"2023-03-27T03:01:39","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=1176"},"modified":"2023-06-26T15:49:37","modified_gmt":"2023-06-26T08:49:37","slug":"csharp-asparallel","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-linq\/csharp-asparallel\/","title":{"rendered":"C# AsParallel"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn how to use the C# AsParallel()<\/code> method to run LINQ queries in parallel.<\/p>\n\n\n\n

Introduction to C# Parallel LINQ<\/h2>\n\n\n\n

When you have a large data set, it takes time to process them. To speed up the calculation, you can divide the large dataset into smaller chunks and process them simultaneously.<\/p>\n\n\n\n

To do that, you use the parallel LINQ or PLINQ in short. PLINQ allows you to execute LINQ queries in parallel across multiple CPU cores.<\/p>\n\n\n\n

PLINQ automatically divides the large data into smaller chunks, distributes them across multiple CPU cores, and aggregates the result back into a single result set.<\/p>\n\n\n\n

PLINQ is useful for CPU-bound operations that require large-scale data processing or complex computations. But it may not be suitable for I\/O bound operations like reading files or accessing data via API.<\/p>\n\n\n\n

Since PLINQ executes the queries in parallel, you need to ensure your code is thread-safe and doesn’t introduce race conditions.<\/p>\n\n\n\n

Creating a parallel query using the C# AsParallel() method<\/h2>\n\n\n\n

To create a parallel query, you follow these steps:<\/p>\n\n\n\n

First, start with a standard LINQ query that operates on an IEnumrable<T><\/code> or IQueryable<T><\/code> data source:<\/p>\n\n\n

IEnumerable<T> source = ...<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Second, call the AsParallel()<\/code> extension method on the data source to create a parallel query:<\/p>\n\n\n
ParallelQuery<T> query = source.AsParallel();<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The AsParallel()<\/code> method returns a parallel query.<\/p>\n\n\n\n
Third, call an operator to execute the query and get the result. For example:<\/p>\n\n\n
var<\/span> result = query.Sum()<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The following program demonstrates how to create a simple parallel query that returns the sum a sequence of integers:<\/p>\n\n\n
using<\/span> static<\/span> System.Console;\nusing<\/span> System.Diagnostics;\n\nstatic<\/span> void<\/span> Measure<\/span>(Func<int<\/span>> f, string<\/span> name<\/span>)<\/span>\n{\n    var<\/span> stopwatch = Stopwatch.StartNew();\n    stopwatch.Start();\n\n    f();\n\n    stopwatch.Stop();\n    WriteLine($\"The method {name}<\/span> took {stopwatch.ElapsedMilliseconds}<\/span> ms to run\"<\/span>);\n}\n\nstatic<\/span> int<\/span> SequentialSum<\/span>(<\/span>)<\/span>\n{\n    return<\/span> Enumerable.Range(0<\/span>, 101<\/span>)\n        .Select(x => {\n            Thread.Sleep(10<\/span>);\n            return<\/span> x;\n        })\n        .Sum();\n}\n\nstatic<\/span> int<\/span> ParallelSum<\/span>(<\/span>)<\/span>\n{\n    return<\/span> Enumerable.Range(0<\/span>, 101<\/span>).AsParallel()\n        .Select(x => {\n            Thread.Sleep(10<\/span>);\n            return<\/span> x;\n         })\n        .Sum();\n}\n\nMeasure(SequentialSum, \"SequentialSum\"<\/span>);\nMeasure(ParallelSum, \"ParallelSum\"<\/span>);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, define the Measure<\/code> method that takes two parameters: the parameter f<\/code> of the type Func<int><\/code> and the parameter name of the type string<\/code>. <\/p>\n\n\n\n
The Func<int><\/code> is a delegate type that represents a function that takes no arguments and returns an integer value. The name<\/code> parameter represents the method name.<\/p>\n\n\n\n
The Measure()<\/code> method measures the execution time of a function f<\/code> using the StopWatch<\/code> object:<\/p>\n\n\n
static<\/span> void<\/span> Measure<\/span>(Func<int<\/span>> f, string<\/span> name<\/span>)<\/span>\n{\n    var<\/span> stopwatch = Stopwatch.StartNew();\n    stopwatch.Start();\n\n    f();\n\n    stopwatch.Stop();\n\n    WriteLine($\"The method {name}<\/span> took {stopwatch.ElapsedMilliseconds}<\/span> ms to run\"<\/span>);\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Second, define the SequentialSum()<\/code> method that calculates the sum of numbers sequentially from 0 to 10001:<\/p>\n\n\n
static<\/span> int<\/span> SequentialSum<\/span>(<\/span>)<\/span>\n{\n    return<\/span> Enumerable.Range(0<\/span>, 101<\/span>)\n        .Select(x => {\n            Thread.Sleep(10<\/span>);\n            return<\/span> x;\n        })\n        .Sum();\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Note that we use the Thread.Sleep(10)<\/code> to simulate time-consuming operations.<\/p>\n\n\n\n
Third, define the ParallelSum()<\/code> method that calculates the sum of numbers from 0 to 10001 in parallel:<\/p>\n\n\n
static<\/span> int<\/span> ParallelSum<\/span>(<\/span>)<\/span>\n{\n    return<\/span> Enumerable.Range(0<\/span>, 101<\/span>).AsParallel()\n        .Select(x => {\n            Thread.Sleep(10<\/span>);\n            return<\/span> x;\n         })\n        .Sum();\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The ParallelSum()<\/code> uses the AsParallel()<\/code> method to convert a query to a parallel query and return the sum of the numbers in the sequence.<\/p>\n\n\n\n
Finally, execute both SequentialSum()<\/code> and ParallelSum()<\/code> method and measure the time they took:<\/p>\n\n\n
Measure(SequentialSum, \"SequentialSum\"<\/span>);\nMeasure(ParallelSum, \"ParallelSum\"<\/span>);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
The method SequentialSum took 1578<\/span> ms to run\nThe method ParallelSum took 293<\/span> ms to run<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The output shows that executing the LINQ query in parallel is faster compared to running it sequentially in this case.<\/p>\n\n\n\n
Important notes of PLINQ<\/h2>\n\n\n\n
As mentioned earlier, parallel LINQ queries only run faster than regular LINQ queries with a large data set or complex computations.<\/p>\n\n\n\n
If you have a small data set with simple calculations, parallel queries may run slower than regular LINQ queries because PLINQ does have some overheads.<\/p>\n\n\n\n
For example, if you remove the Thread.Sleep(10)<\/code> of the lambda expression in the Select()<\/a><\/code> method, you’ll see that the SequentialSum()<\/code> method runs faster than ParallelSum()<\/code> method:<\/p>\n\n\n
using<\/span> static<\/span> System.Console;\nusing<\/span> System.Diagnostics;\n\nstatic<\/span> void<\/span> Measure<\/span>(Func<int<\/span>> f, string<\/span> name<\/span>)<\/span>\n{\n    var<\/span> stopwatch = Stopwatch.StartNew();\n    stopwatch.Start();\n\n    f();\n\n    stopwatch.Stop();\n    \n    WriteLine($\"The method {name}<\/span> took {stopwatch.ElapsedMilliseconds}<\/span> ms to run\"<\/span>);\n}\n\nstatic<\/span> int<\/span> SequentialSum<\/span>(<\/span>)<\/span>\n{\n    return<\/span> Enumerable.Range(0<\/span>, 101<\/span>)\n        .Select(x => {\n            \/\/Thread.Sleep(10);<\/span>\n            return<\/span> x;\n        })\n        .Sum();\n}\n\nstatic<\/span> int<\/span> ParallelSum<\/span>(<\/span>)<\/span>\n{\n    return<\/span> Enumerable.Range(0<\/span>, 101<\/span>).AsParallel()\n        .Select(x => {\n            \/\/Thread.Sleep(10);<\/span>\n            return<\/span> x;\n         })\n        .Sum();\n}\n\nMeasure(SequentialSum, \"SequentialSum\"<\/span>);\nMeasure(ParallelSum, \"ParallelSum\"<\/span>);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
The method SequentialSum took 2<\/span> ms to run\nThe method ParallelSum took 74<\/span> ms to run<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Summary<\/h2>\n\n\n\n
    \n
  • PLINQ allows you to execute LINQ queries in parallel across multiple CPU cores.<\/li>\n\n\n\n
  • Use AsParallel()<\/code> method to execute parallel LINQ queries.<\/li>\n<\/ul>\n
    \n\t
    \n\t\t
    Was this tutorial helpful ?<\/div>\n\t\t
    \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t\n\t\t\t