C# Language
Parallel LINQ (PLINQ)

Syntaxis

• ParallelEnumerable.Aggregate (func)
• ParallelEnumerable.Aggregate (seed, func)
• ParallelEnumerable.Aggregate (seed, updateAccumulatorFunc, combinerenAccumulatorsFunc, resultSelector)
• ParallelEnumerable.Aggregate (seedFactory, updateAccumulatorFunc, combinerenAccumulatorsFunc, resultSelector)
• ParallelEnumerable.All (predikaat)
• ParallelEnumerable.Any ()
• ParallelEnumerable.Any (predikaat)
• ParallelEnumerable.AsEnumerable ()
• ParallelEnumerable.AsOrdered ()
• ParallelEnumerable.AsParallel ()
• ParallelEnumerable.AsSequential ()
• ParallelEnumerable.AsUnordered ()
• ParallelEnumerable.Average (selector)
• ParallelEnumerable.Cast ()
• ParallelEnumerable.Concat (tweede)
• ParallelEnumerable.Contains (value)
• ParallelEnumerable.Contains (value, comparer)
• ParallelEnumerable.Count ()
• ParallelEnumerable.Count (predikaat)
• ParallelEnumerable.DefaultIfEmpty ()
• ParallelEnumerable.DefaultIfEmpty (defaultValue)
• ParallelEnumerable.Distinct ()
• ParallelEnumerable.Distinct (comparator)
• ParallelEnumerable.ElementAt (index)
• ParallelEnumerable.ElementAtOrDefault (index)
• ParallelEnumerable.Empty ()
• ParallelEnumerable.Except (tweede)
• ParallelEnumerable.Except (tweede, vergelijker)
• ParallelEnumerable.First ()
• ParallelEnumerable.First (predikaat)
• ParallelEnumerable.FirstOrDefault ()
• ParallelEnumerable.FirstOrDefault (predikaat)
• ParallelEnumerable.ForAll (actie)
• ParallelEnumerable.GroupBy (keySelector)
• ParallelEnumerable.GroupBy (keySelector, comparer)
• ParallelEnumerable.GroupBy (keySelector, elementSelector)
• ParallelEnumerable.GroupBy (keySelector, elementSelector, comparer)
• ParallelEnumerable.GroupBy (keySelector, resultSelector)
• ParallelEnumerable.GroupBy (keySelector, resultSelector, comparer)
• ParallelEnumerable.GroupBy (keySelector, elementSelector, ruleSelector)
• ParallelEnumerable.GroupBy (keySelector, elementSelector, ruleSelector, comparer)
• ParallelEnumerable.GroupJoin (inner, outerKeySelector, innerKeySelector, resultSelector)
• ParallelEnumerable.GroupJoin (inner, outerKeySelector, innerKeySelector, resultSelector, comparer)
• ParallelEnumerable.Intersect (tweede)
• ParallelEnumerable.Intersect (tweede, vergelijker)
• ParallelEnumerable.Join (inner, outerKeySelector, innerKeySelector, resultSelector)
• ParallelEnumerable.Join (inner, outerKeySelector, innerKeySelector, resultSelector, comparer)
• ParallelEnumerable.Last ()
• ParallelEnumerable.Last (predikaat)
• ParallelEnumerable.LastOrDefault ()
• ParallelEnumerable.LastOrDefault (predikaat)
• ParallelEnumerable.LongCount ()
• ParallelEnumerable.LongCount (predikaat)
• ParallelEnumerable.Max ()
• ParallelEnumerable.Max (selector)
• ParallelEnumerable.Min ()
• ParallelEnumerable.Min (selector)
• ParallelEnumerable.OfType ()
• ParallelEnumerable.OrderBy (keySelector)
• ParallelEnumerable.OrderBy (keySelector, comparer)
• ParallelEnumerable.OrderByDescending (keySelector)
• ParallelEnumerable.OrderByDescending (keySelector, comparer)
• ParallelEnumerable.Range (start, count)
• ParallelEnumerable.Repeat (element, count)
• ParallelEnumerable.Reverse ()
• ParallelEnumerable.Select (selector)
• ParallelEnumerable.SelectMany (selector)
• ParallelEnumerable.SelectMany (collectionSelector, resultSelector)
• ParallelEnumerable.SequenceEqual (tweede)
• ParallelEnumerable.SequenceEqual (tweede, vergelijker)
• ParallelEnumerable.Single ()
• ParallelEnumerable.Single (predikaat)
• ParallelEnumerable.SingleOrDefault ()
• ParallelEnumerable.SingleOrDefault (predikaat)
• ParallelEnumerable.Skip (count)
• ParallelEnumerable.SkipWhile (predikaat)
• ParallelEnumerable.Sum ()
• ParallelEnumerable.Sum (selector)
• ParallelEnumerable.Take (count)
• ParallelEnumerable.TakeWhile (predikaat)
• ParallelEnumerable.ThenBy (keySelector)
• ParallelEnumerable.ThenBy (keySelector, comparer)
• ParallelEnumerable.ThenByDescending (keySelector)
• ParallelEnumerable.ThenByDescending (keySelector, comparer)
• ParallelEnumerable.ToArray ()
• ParallelEnumerable.ToDictionary (keySelector)
• ParallelEnumerable.ToDictionary (keySelector, comparer)
• ParallelEnumerable.ToDictionary (elementSelector)
• ParallelEnumerable.ToDictionary (elementSelector, comparer)
• ParallelEnumerable.ToList ()
• ParallelEnumerable.ToLookup (keySelector)
• ParallelEnumerable.ToLookup (keySelector, comparer)
• ParallelEnumerable.ToLookup (keySelector, elementSelector)
• ParallelEnumerable.ToLookup (keySelector, elementSelector, comparer)
• ParallelEnumerable.Union (tweede)
• ParallelEnumerable.Union (tweede, vergelijker)
• ParallelEnumerable.Where (predikaat)
• ParallelEnumerable.WithCancellation (cancellationToken)
• ParallelEnumerable.WithDegreeOfParallelism (degreeOfParallelism)
• ParallelEnumerable.WithExecutionMode (executionMode)
• ParallelEnumerable.WithMergeOptions (mergeOptions)
• ParallelEnumerable.Zip (tweede, resultSelector)

Eenvoudig voorbeeld

Dit voorbeeld laat zien hoe PLINQ kan worden gebruikt om de even getallen tussen 1 en 10.000 te berekenen met behulp van meerdere threads. Merk op dat de resulterende lijst niet zal worden besteld!

var sequence = Enumerable.Range(1, 10000);
var evenNumbers = sequence.AsParallel()
                          .Where(x => x % 2 == 0)
                          .ToList();

// evenNumbers = { 4, 26, 28, 30, ... }
// Order will vary with different runs

WithDegreeOfParallelism

De mate van parallellisme is het maximale aantal gelijktijdig uitgevoerde taken dat zal worden gebruikt om de query te verwerken.

var sequence = Enumerable.Range(1, 10000);
var evenNumbers = sequence.AsParallel()
                          .WithDegreeOfParallelism(4)
                          .Where(x => x % 2 == 0);

AsOrdered

Dit voorbeeld laat zien hoe PLINQ kan worden gebruikt om de even getallen tussen 1 en 10.000 te berekenen met behulp van meerdere threads. De volgorde wordt in de resulterende lijst gehandhaafd, maar houd er rekening mee dat AsOrdered prestaties voor een groot aantal elementen kan schaden, dus niet-geordende verwerking heeft de voorkeur indien mogelijk.

var sequence = Enumerable.Range(1, 10000);
var evenNumbers = sequence.AsParallel()
                          .AsOrdered()
                          .Where(x => x % 2 == 0)
                          .ToList();

// evenNumbers = { 2, 4, 6, 8, ..., 10000 }

AsUnordered

Geordende sequenties kunnen de prestaties nadelig beïnvloeden bij het omgaan met een groot aantal elementen. Om dit te verminderen, is het mogelijk om AsUnordered aan te roepen wanneer de volgorde niet langer nodig is.

var sequence = Enumerable.Range(1, 10000).Select(x => -1 * x); // -1, -2, ...
var evenNumbers = sequence.AsParallel()
                          .OrderBy(x => x)
                          .Take(5000)
                          .AsUnordered()
                          .Where(x => x % 2 == 0) // This line won't be affected by ordering
                          .ToList();