C# Language
Parallell LINQ (PLINQ)

Syntax

• ParallelEnumerable.Aggregate (func)
• ParallelEnumerable.Aggregate (frö, func)
• ParallelEnumerable.Aggregate (seed, updateAccumulatorFunc, combineAccumulatorsFunc, resultSelector)
• ParallelEnumerable.Aggregate (seedFactory, updateAccumulatorFunc, combineAccumulatorsFunc, resultSelector)
• ParallelEnumerable.All (predikat)
• ParallelEnumerable.Any ()
• ParallelEnumerable.Any (predikat)
• ParallelEnumerable.AsEnumerable ()
• ParallelEnumerable.AsOrdered ()
• ParallelEnumerable.AsParallel ()
• ParallelEnumerable.AsSequential ()
• ParallelEnumerable.AsUnordered ()
• ParallelEnumerable.Average (väljare)
• ParallelEnumerable.Cast ()
• ParallelEnumerable.Concat (andra)
• ParallelEnumerable.Contains (värde)
• ParallelEnumerable.Contains (värde, jämförare)
• ParallelEnumerable.Count ()
• ParallelEnumerable.Count (predikat)
• ParallelEnumerable.DefaultIfEmpty ()
• ParallelEnumerable.DefaultIfEmpty (default)
• ParallelEnumerable.Distinct ()
• ParallelEnumerable.Distinct (Comparer)
• ParallelEnumerable.ElementAt (index)
• ParallelEnumerable.ElementAtOrDefault (index)
• ParallelEnumerable.Empty ()
• ParallelEnumerable.Except (andra)
• ParallelEnumerable.Except (andra, jämförare)
• ParallelEnumerable.First ()
• ParallelEnumerable.First (predikat)
• ParallelEnumerable.FirstOrDefault ()
• ParallelEnumerable.FirstOrDefault (predikat)
• ParallelEnumerable.ForAll (verkan)
• ParallelEnumerable.GroupBy (keySelector)
• ParallelEnumerable.GroupBy (keySelector, jämförare)
• ParallelEnumerable.GroupBy (keySelector, elementSelector)
• ParallelEnumerable.GroupBy (keySelector, elementSelector, jämförare)
• ParallelEnumerable.GroupBy (keySelector, resultSelector)
• ParallelEnumerable.GroupBy (keySelector, resultSelector, jämförare)
• ParallelEnumerable.GroupBy (keySelector, elementSelector, ruleSelector)
• ParallelEnumerable.GroupBy (keySelector, elementSelector, ruleSelector, jämförare)
• ParallelEnumerable.GroupJoin (inner, ytterKeySelector, innerKeySelector, resultSelector)
• ParallelEnumerable.GroupJoin (inner, ytterKeySelector, innerKeySelector, resultSelector, jämförare)
• ParallelEnumerable.Intersect (andra)
• ParallelEnumerable.Intersect (andra, jämförare)
• ParallelEnumerable.Join (inner, ytterKeySelector, innerKeySelector, resultSelector)
• ParallelEnumerable.Join (inner, ytterKeySelector, innerKeySelector, resultSelector, jämförare)
• ParallelEnumerable.Last ()
• ParallelEnumerable.Last (predikat)
• ParallelEnumerable.LastOrDefault ()
• ParallelEnumerable.LastOrDefault (predikat)
• ParallelEnumerable.LongCount ()
• ParallelEnumerable.LongCount (predikat)
• ParallelEnumerable.Max ()
• ParallelEnumerable.Max (väljare)
• ParallelEnumerable.Min ()
• ParallelEnumerable.Min (väljare)
• ParallelEnumerable.OfType ()
• ParallelEnumerable.OrderBy (keySelector)
• ParallelEnumerable.OrderBy (keySelector, jämförare)
• ParallelEnumerable.OrderByDescending (keySelector)
• ParallelEnumerable.OrderByDescending (keySelector, jämförare)
• ParallelEnumerable.Range (start, räkna)
• ParallelEnumerable.Repeat (element, count)
• ParallelEnumerable.Reverse ()
• ParallelEnumerable.Select (väljare)
• ParallelEnumerable.SelectMany (väljare)
• ParallelEnumerable.SelectMany (collectionSelector, resultSelector)
• ParallelEnumerable.SequenceEqual (andra)
• ParallelEnumerable.SequenceEqual (andra, jämförare)
• ParallelEnumerable.Single ()
• ParallelEnumerable.Single (predikat)
• ParallelEnumerable.SingleOrDefault ()
• ParallelEnumerable.SingleOrDefault (predikat)
• ParallelEnumerable.Skip (count)
• ParallelEnumerable.SkipWhile (predikat)
• ParallelEnumerable.Sum ()
• ParallelEnumerable.Sum (väljare)
• ParallelEnumerable.Take (count)
• ParallelEnumerable.TakeWhile (predikat)
• ParallelEnumerable.ThenBy (keySelector)
• ParallelEnumerable.ThenBy (keySelector, jämförare)
• ParallelEnumerable.ThenByDescending (keySelector)
• ParallelEnumerable.ThenByDescending (keySelector, jämförare)
• ParallelEnumerable.ToArray ()
• ParallelEnumerable.ToDictionary (keySelector)
• ParallelEnumerable.ToDiction (keySelector, jämförare)
• ParallelEnumerable.ToDictionary (elementSelector)
• ParallelEnumerable.ToDiction (elementSelector, jämförare)
• ParallelEnumerable.ToList ()
• ParallelEnumerable.ToLookup (keySelector)
• ParallelEnumerable.ToLookup (keySelector, jämförare)
• ParallelEnumerable.ToLookup (keySelector, elementSelector)
• ParallelEnumerable.ToLookup (keySelector, elementSelector, jämförare)
• ParallelEnumerable.Union (andra)
• ParallelEnumerable.Union (andra, jämförare)
• ParallelEnumerable.Where (predikat)
• ParallelEnumerable.WithCancellation (cancellationToken)
• ParallelEnumerable.WithDegreeOfParallelism (degreeOfParallelism)
• ParallelEnumerable.WithExecutionMode (executionMode)
• ParallelEnumerable.WithMergeOptions (mergeOptions)
• ParallelEnumerable.Zip (andra, resultatSelector)

Enkelt exempel

Detta exempel visar hur PLINQ kan användas för att beräkna jämna siffror mellan 1 och 10 000 med flera trådar. Observera att den resulterande listan inte kommer att beställas!

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

Graden av parallellism är det maximala antalet samtidigt exekverande uppgifter som kommer att användas för att bearbeta frågan.

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

AsOrdered

Detta exempel visar hur PLINQ kan användas för att beräkna jämna siffror mellan 1 och 10 000 med flera trådar. Order kommer att upprätthållas i den resulterande listan, men kom ihåg att AsOrdered kan skada prestanda för ett stort antal element, så att obeställd behandling föredras när det är möjligt.

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

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

AsUnordered

Beställda sekvenser kan skada prestanda när det handlar om ett stort antal element. För att mildra detta är det möjligt att ringa AsUnordered när sekvensordningen inte längre är nödvändig.

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