C# Language
Parallele LINQ (PLINQ)

Syntax

• ParallelEnumerable.Aggregate (func)
• ParallelEnumerable.Aggregate (Seed, func)
• ParallelEnumerable.Aggregate (Seed, updateAccumulatorFunc, CombineAccumulatorsFunc, ResultSelector)
• ParallelEnumerable.Aggregate (seedFactory, updateAccumulatorFunc, CombineAccumulatorsFunc, resultSelector)
• ParallelEnumerable.All (Prädikat)
• ParallelEnumerable.Any ()
• ParallelEnumerable.Any (Prädikat)
• ParallelEnumerable.AsEnumerable ()
• ParallelEnumerable.AsOrdered ()
• ParallelEnumerable.AsParallel ()
• ParallelEnumerable.AsSequential ()
• ParallelEnumerable.AsUnordered ()
• ParallelEnumerable.Average (Auswahl)
• ParallelEnumerable.Cast ()
• ParallelEnumerable.Concat (Sekunde)
• ParallelEnumerable.Contains (Wert)
• ParallelEnumerable.Contains (Wert, Vergleicher)
• ParallelEnumerable.Count ()
• ParallelEnumerable.Count (Prädikat)
• ParallelEnumerable.DefaultIfEmpty ()
• ParallelEnumerable.DefaultIfEmpty (defaultValue)
• ParallelEnumerable.Distinct ()
• ParallelEnumerable.Distinct (Vergleicher)
• ParallelEnumerable.ElementAt (Index)
• ParallelEnumerable.ElementAtOrDefault (Index)
• ParallelEnumerable.Empty ()
• ParallelEnumerable.Except (Sekunde)
• ParallelEnumerable.Except (zweiter Vergleicher)
• ParallelEnumerable.First ()
• ParallelEnumerable.First (Prädikat)
• ParallelEnumerable.FirstOrDefault ()
• ParallelEnumerable.FirstOrDefault (Prädikat)
• ParallelEnumerable.ForAll (Aktion)
• ParallelEnumerable.GroupBy (keySelector)
• ParallelEnumerable.GroupBy (keySelector, Vergleicher)
• ParallelEnumerable.GroupBy (keySelector, elementSelector)
• ParallelEnumerable.GroupBy (keySelector, elementSelector, Vergleicher)
• ParallelEnumerable.GroupBy (keySelector, resultSelector)
• ParallelEnumerable.GroupBy (keySelector, resultSelector, Vergleicher)
• ParallelEnumerable.GroupBy (keySelector, elementSelector, ruleSelector)
• ParallelEnumerable.GroupBy (keySelector, elementSelector, ruleSelector, Vergleicher)
• ParallelEnumerable.GroupJoin (inner, outerKeySelector, innerKeySelector, resultSelector)
• ParallelEnumerable.GroupJoin (inner, outerKeySelector, innerKeySelector, resultSelector, Vergleicher)
• ParallelEnumerable.Intersect (second)
• ParallelEnumerable.Intersect (zweiter Vergleicher)
• ParallelEnumerable.Join (inner, outerKeySelector, innerKeySelector, resultSelector)
• ParallelEnumerable.Join (inner, outerKeySelector, innerKeySelector, resultSelector, Vergleicher)
• ParallelEnumerable.Last ()
• ParallelEnumerable.Last (Prädikat)
• ParallelEnumerable.LastOrDefault ()
• ParallelEnumerable.LastOrDefault (Prädikat)
• ParallelEnumerable.LongCount ()
• ParallelEnumerable.LongCount (Prädikat)
• ParallelEnumerable.Max ()
• ParallelEnumerable.Max (Auswahl)
• ParallelEnumerable.Min ()
• ParallelEnumerable.Min (Selektor)
• ParallelEnumerable.OfType ()
• ParallelEnumerable.OrderBy (keySelector)
• ParallelEnumerable.OrderBy (keySelector, Vergleicher)
• ParallelEnumerable.OrderByDescending (keySelector)
• ParallelEnumerable.OrderByDescending (keySelector, Vergleicher)
• ParallelEnumerable.Range (Start, Anzahl)
• ParallelEnumerable.Repeat (Element, Anzahl)
• ParallelEnumerable.Reverse ()
• ParallelEnumerable.Select (Auswahl)
• ParallelEnumerable.SelectMany (Selektor)
• ParallelEnumerable.SelectMany (collectionSelector, resultSelector)
• ParallelEnumerable.SequenceEqual (second)
• ParallelEnumerable.SequenceEqual (second, comparer)
• ParallelEnumerable.Single ()
• ParallelEnumerable.Single (Prädikat)
• ParallelEnumerable.SingleOrDefault ()
• ParallelEnumerable.SingleOrDefault (Prädikat)
• ParallelEnumerable.Skip (Anzahl)
• ParallelEnumerable.SkipWhile (Prädikat)
• ParallelEnumerable.Sum ()
• ParallelEnumerable.Sum (Auswahl)
• ParallelEnumerable.Take (Anzahl)
• ParallelEnumerable.TakeWhile (Prädikat)
• ParallelEnumerable.ThenBy (keySelector)
• ParallelEnumerable.ThenBy (keySelector, Vergleicher)
• ParallelEnumerable.ThenByDescending (keySelector)
• ParallelEnumerable.ThenByDescending (keySelector, Vergleicher)
• ParallelEnumerable.ToArray ()
• ParallelEnumerable.ToDictionary (keySelector)
• ParallelEnumerable.ToDictionary (keySelector, Vergleicher)
• ParallelEnumerable.ToDictionary (elementSelector)
• ParallelEnumerable.ToDictionary (elementSelector, Vergleicher)
• ParallelEnumerable.ToList ()
• ParallelEnumerable.ToLookup (keySelector)
• ParallelEnumerable.ToLookup (keySelector, Vergleicher)
• ParallelEnumerable.ToLookup (keySelector, elementSelector)
• ParallelEnumerable.ToLookup (keySelector, elementSelector, Vergleicher)
• ParallelEnumerable.Union (Sekunde)
• ParallelEnumerable.Union (zweiter Vergleicher)
• ParallelEnumerable.Where (Prädikat)
• ParallelEnumerable.WithCancellation (Annullierungstoken)
• ParallelEnumerable.WithDegreeOfParallelism (GradOfParallelism)
• ParallelEnumerable.WithExecutionMode (executionMode)
• ParallelEnumerable.WithMergeOptions (mergeOptions)
• ParallelEnumerable.Zip (zweiter resultSelector)

Einfaches Beispiel

Dieses Beispiel zeigt, wie PLINQ verwendet werden kann, um die geraden Zahlen zwischen 1 und 10.000 mit mehreren Threads zu berechnen. Beachten Sie, dass die Ergebnisliste nicht bestellt wird!

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

Der Parallelitätsgrad ist die maximale Anzahl gleichzeitig ausgeführter Aufgaben, die zur Verarbeitung der Abfrage verwendet werden.

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

AsOrdered

Dieses Beispiel zeigt, wie PLINQ verwendet werden kann, um die geraden Zahlen zwischen 1 und 10.000 mit mehreren Threads zu berechnen. Die Reihenfolge wird in der Ergebnisliste beibehalten. AsOrdered jedoch, dass AsOrdered die Leistung einer großen Anzahl von Elementen AsOrdered kann. AsOrdered wird nach Möglichkeit eine AsOrdered Verarbeitung bevorzugt.

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

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

AsUnordered

Geordnete Sequenzen können die Leistung beeinträchtigen, wenn Sie mit einer großen Anzahl von Elementen arbeiten. Um dies zu mildern, ist es möglich, AsUnordered wenn die Sequenzreihenfolge nicht mehr erforderlich ist.

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();