C# Language
LINQ parallelo (PLINQ)

Sintassi

• ParallelEnumerable.Aggregate (func)
• ParallelEnumerable.Aggregate (seed, func)
• ParallelEnumerable.Aggregate (seed, updateAccumulatorFunc, combineAccumulatorsFunc, resultSelector)
• ParallelEnumerable.Aggregate (seedFactory, updateAccumulatorFunc, combineAccumulatorsFunc, resultSelector)
• ParallelEnumerable.All (predicato)
• ParallelEnumerable.Any ()
• ParallelEnumerable.Any (predicato)
• ParallelEnumerable.AsEnumerable ()
• ParallelEnumerable.AsOrdered ()
• ParallelEnumerable.AsParallel ()
• ParallelEnumerable.AsSequential ()
• ParallelEnumerable.AsUnordered ()
• ParallelEnumerable.Average (selettore)
• ParallelEnumerable.Cast ()
• ParallelEnumerable.Concat (secondo)
• ParallelEnumerable.Contains (valore)
• ParallelEnumerable.Contains (valore, comparatore)
• ParallelEnumerable.Count ()
• ParallelEnumerable.Count (predicato)
• ParallelEnumerable.DefaultIfEmpty ()
• ParallelEnumerable.DefaultIfEmpty (defaultValue)
• ParallelEnumerable.Distinct ()
• ParallelEnumerable.Distinct (di confronto)
• ParallelEnumerable.ElementAt (indice)
• ParallelEnumerable.ElementAtOrDefault (indice)
• ParallelEnumerable.Empty ()
• ParallelEnumerable.Except (secondo)
• ParallelEnumerable.Except (second, comparer)
• ParallelEnumerable.First ()
• ParallelEnumerable.First (predicato)
• ParallelEnumerable.FirstOrDefault ()
• ParallelEnumerable.FirstOrDefault (predicato)
• ParallelEnumerable.ForAll (azione)
• ParallelEnumerable.GroupBy (keySelector)
• ParallelEnumerable.GroupBy (keySelector, comparatore)
• ParallelEnumerable.GroupBy (keySelector, elementSelector)
• ParallelEnumerable.GroupBy (keySelector, elementSelector, comparatore)
• ParallelEnumerable.GroupBy (keySelector, resultSelector)
• ParallelEnumerable.GroupBy (keySelector, resultSelector, comparatore)
• ParallelEnumerable.GroupBy (keySelector, elementSelector, ruleSelector)
• ParallelEnumerable.GroupBy (keySelector, elementSelector, ruleSelector, comparatore)
• ParallelEnumerable.GroupJoin (inner, outerKeySelector, innerKeySelector, resultSelector)
• ParallelEnumerable.GroupJoin (inner, outerKeySelector, innerKeySelector, resultSelector, comparatore)
• ParallelEnumerable.Intersect (secondo)
• ParallelEnumerable.Intersect (secondo, comparatore)
• ParallelEnumerable.Join (inner, outerKeySelector, innerKeySelector, resultSelector)
• ParallelEnumerable.Join (inner, outerKeySelector, innerKeySelector, resultSelector, comparatore)
• ParallelEnumerable.Last ()
• ParallelEnumerable.Last (predicato)
• ParallelEnumerable.LastOrDefault ()
• ParallelEnumerable.LastOrDefault (predicato)
• ParallelEnumerable.LongCount ()
• ParallelEnumerable.LongCount (predicato)
• ParallelEnumerable.Max ()
• ParallelEnumerable.Max (selettore)
• ParallelEnumerable.Min ()
• ParallelEnumerable.Min (selettore)
• ParallelEnumerable.OfType ()
• ParallelEnumerable.OrderBy (keySelector)
• ParallelEnumerable.OrderBy (keySelector, comparatore)
• ParallelEnumerable.OrderByDescending (keySelector)
• ParallelEnumerable.OrderByDescending (keySelector, comparatore)
• ParallelEnumerable.Range (start, count)
• ParallelEnumerable.Repeat (element, count)
• ParallelEnumerable.Reverse ()
• ParallelEnumerable.Select (selettore)
• ParallelEnumerable.SelectMany (selettore)
• ParallelEnumerable.SelectMany (collectionSelector, resultSelector)
• ParallelEnumerable.SequenceEqual (secondo)
• ParallelEnumerable.SequenceEqual (secondo, comparatore)
• ParallelEnumerable.Single ()
• ParallelEnumerable.Single (predicato)
• ParallelEnumerable.SingleOrDefault ()
• ParallelEnumerable.SingleOrDefault (predicato)
• ParallelEnumerable.Skip (conteggio)
• ParallelEnumerable.SkipWhile (predicato)
• ParallelEnumerable.Sum ()
• ParallelEnumerable.Sum (selettore)
• ParallelEnumerable.Take (conteggio)
• ParallelEnumerable.TakeWhile (predicato)
• ParallelEnumerable.ThenBy (keySelector)
• ParallelEnumerable.ThenBy (keySelector, comparatore)
• ParallelEnumerable.ThenByDescending (keySelector)
• ParallelEnumerable.ThenByDescending (keySelector, comparatore)
• ParallelEnumerable.ToArray ()
• ParallelEnumerable.ToDictionary (keySelector)
• ParallelEnumerable.ToDictionary (keySelector, comparatore)
• ParallelEnumerable.ToDictionary (elementSelector)
• ParallelEnumerable.ToDictionary (elementSelector, comparatore)
• ParallelEnumerable.ToList ()
• ParallelEnumerable.ToLookup (keySelector)
• ParallelEnumerable.ToLookup (keySelector, comparatore)
• ParallelEnumerable.ToLookup (keySelector, elementSelector)
• ParallelEnumerable.ToLookup (keySelector, elementSelector, comparatore)
• ParallelEnumerable.Union (secondo)
• ParallelEnumerable.Union (secondo, comparatore)
• ParallelEnumerable.Where (predicato)
• ParallelEnumerable.WithCancellation (CancellationToken)
• ParallelEnumerable.WithDegreeOfParallelism (degreeOfParallelism)
• ParallelEnumerable.WithExecutionMode (executionMode)
• ParallelEnumerable.WithMergeOptions (mergeOptions)
• ParallelEnumerable.Zip (second, resultSelector)

Semplice esempio

Questo esempio mostra come PLINQ può essere utilizzato per calcolare i numeri pari tra 1 e 10.000 utilizzando più thread. Si noti che la lista risultante non sarà ordinata!

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

Il grado di parallelismo è il numero massimo di attività di esecuzione simultanee che verranno utilizzate per elaborare la query.

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

AsOrdered

Questo esempio mostra come PLINQ può essere utilizzato per calcolare i numeri pari tra 1 e 10.000 utilizzando più thread. L'ordine verrà mantenuto nell'elenco risultante, tuttavia tieni presente che AsOrdered può danneggiare le prestazioni per un numero elevato di elementi, pertanto l'elaborazione non ordinata viene preferita quando possibile.

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

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

AsUnordered

Le sequenze ordinate possono danneggiare le prestazioni quando si ha a che fare con un gran numero di elementi. Per mitigarlo, è possibile chiamare AsUnordered quando l'ordine della sequenza non è più necessario.

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