C# Language
LINQ paralelo (PLINQ)

Sintaxis

• ParallelEnumerable.Aggregate (func)
• ParallelEnumerable.Aggregate (semilla, func)
• ParallelEnumerable.Aggregate (seed, updateAccumulatorFunc, combineAcculaulatorFunc, resultSelector)
• ParallelEnumerable.Aggregate (seedFactory, updateAccumulatorFunc, combineAccumulatorsFunc, resultSelector)
• ParallelEnumerable.All (predicado)
• ParallelEnumerable.Any ()
• ParallelEnumerable.Any (predicado)
• ParallelEnumerable.AsEnumerable ()
• ParallelEnumerable.AsOrdered ()
• ParallelEnumerable.AsParallel ()
• ParallelEnumerable.AsSequential ()
• ParallelEnumerable.AsUnordered ()
• ParallelEnumerable.Average (selector)
• ParallelEnumerable.Cast ()
• ParallelEnumerable.Concat (segundo)
• ParallelEnumerable.Contains (valor)
• ParallelEnumerable.Contains (valor, comparador)
• ParallelEnumerable.Count ()
• ParallelEnumerable.Count (predicado)
• ParallelEnumerable.DefaultIfEmpty ()
• ParallelEnumerable.DefaultIfEmpty (defaultValue)
• ParaleloEnumerable.Distinto ()
• ParaleloEnumerable.Distinto (comparador)
• ParallelEnumerable.ElementAt (index)
• ParallelEnumerable.ElementAtOrDefault (índice)
• ParallelEnumerable.Empty ()
• ParallelEnumerable.Except (segundo)
• ParallelEnumerable.Except (segundo, comparador)
• ParallelEnumerable.First ()
• ParallelEnumerable.First (predicado)
• ParallelEnumerable.FirstOrDefault ()
• ParallelEnumerable.FirstOrDefault (predicado)
• ParallelEnumerable.ForAll (action)
• 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 (segundo)
• ParallelEnumerable.Intersect (segundo, comparador)
• ParallelEnumerable.Join (inner, outerKeySelector, innerKeySelector, resultSelector)
• ParallelEnumerable.Join (inner, outerKeySelector, innerKeySelector, resultSelector, comparer)
• ParallelEnumerable.Last ()
• ParallelEnumerable.Last (predicado)
• ParallelEnumerable.LastOrDefault ()
• ParallelEnumerable.LastOrDefault (predicado)
• ParallelEnumerable.LongCount ()
• ParallelEnumerable.LongCount (predicado)
• 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 (iniciar, contar)
• ParallelEnumerable.Repeat (elemento, count)
• ParallelEnumerable.Reverse ()
• ParallelEnumerable.Select (selector)
• ParallelEnumerable.SelectMany (selector)
• ParallelEnumerable.SelectMany (collectionSelector, resultSelector)
• ParallelEnumerable.SequenceEqual (segundo)
• ParallelEnumerable.SequenceEqual (segundo, comparador)
• ParallelEnumerable.Single ()
• ParallelEnumerable.Single (predicado)
• ParallelEnumerable.SingleOrDefault ()
• ParallelEnumerable.SingleOrDefault (predicado)
• ParallelEnumerable.Skip (count)
• ParallelEnumerable.SkipWhile (predicado)
• ParallelEnumerable.Sum ()
• ParallelEnumerable.Sum (selector)
• ParallelEnumerable.Take (count)
• ParallelEnumerable.TakeWhile (predicado)
• 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 (segundo)
• ParallelEnumerable.Union (segundo, comparador)
• ParallelEnumerable.Where (predicado)
• ParallelEnumerable.WithCancellation (cancelaciónToken)
• ParallelEnumerable.WithDegreeOfParallelism (degreeOfParallelism)
• ParallelEnumerable.WithExecutionMode (ecutionMode)
• ParallelEnumerable.WithMergeOptions (mergeOptions)
• ParallelEnumerable.Zip (segundo, resultSelector)

Ejemplo simple

Este ejemplo muestra cómo se puede usar PLINQ para calcular los números pares entre 1 y 10,000 usando múltiples subprocesos. Tenga en cuenta que la lista resultante no será ordenada!

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

ConDegreeOfParalelismo

El grado de paralelismo es el número máximo de tareas que se ejecutan simultáneamente para procesar la consulta.

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

Según lo ordenado

Este ejemplo muestra cómo se puede usar PLINQ para calcular los números pares entre 1 y 10,000 usando múltiples subprocesos. El orden se mantendrá en la lista resultante, sin embargo, tenga en cuenta que AsOrdered puede afectar el rendimiento de una gran cantidad de elementos, por lo que es preferible el procesamiento no ordenado cuando sea posible.

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

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

As Sin orden

Las secuencias ordenadas pueden afectar el rendimiento cuando se trata de una gran cantidad de elementos. Para mitigar esto, es posible llamar a AsUnordered cuando el orden de la secuencia ya no es necesario.

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