C# Language
Równoległe LINQ (PLINQ)

Składnia

• ParallelEnumerable.Aggregate (func)
• ParallelEnumerable.Aggregate (seed, func)
• ParallelEnumerable.Aggregate (seed, updateAccumulatorFunc, CombineAccumulatorsFunc, resultSelector)
• ParallelEnumerable.Aggregate (seedFactory, updateAccumulatorFunc, CombineAccumulatorsFunc, resultSelector)
• ParallelEnumerable.All (predicate)
• ParallelEnumerable.Any ()
• ParallelEnumerable.Any (predicate)
• ParallelEnumerable.AsEnumerable ()
• ParallelEnumerable.AsOrders ()
• ParallelEnumerable.AsParallel ()
• ParallelEnumerable.AsSequential ()
• ParallelEnumerable.AsUnordered ()
• ParallelEnumerable.A Average (selektor)
• ParallelEnumerable.Cast ()
• ParallelEnumerable.Concat (drugi)
• ParallelEnumerable.Contains (wartość)
• ParallelEnumerable.Contains (wartość, moduł porównujący)
• ParallelEnumerable.Count ()
• ParallelEnumerable.Count (predicate)
• ParallelEnumerable.DefaultIfEmpty ()
• ParallelEnumerable.DefaultIfEmpty (defaultValue)
• ParallelEnumerable.Distinct ()
• ParallelEnumerable.Distinct (porównaj)
• ParallelEnumerable.ElementAt (indeks)
• ParallelEnumerable.ElementAtOrDefault (indeks)
• ParallelEnumerable.Empty ()
• ParallelEnumerable.Except (second)
• ParallelEnumerable.Except (drugi, moduł porównujący)
• ParallelEnumerable.First ()
• ParallelEnumerable.First (predicate)
• ParallelEnumerable.FirstOrDefault ()
• ParallelEnumerable.FirstOrDefault (predykat)
• ParallelEnumerable.ForAll (akcja)
• ParallelEnumerable.GroupBy (keySelector)
• ParallelEnumerable.GroupBy (keySelector, porównywarka)
• ParallelEnumerable.GroupBy (keySelector, elementSelector)
• ParallelEnumerable.GroupBy (keySelector, elementSelector, porównywarka)
• ParallelEnumerable.GroupBy (keySelector, resultSelector)
• ParallelEnumerable.GroupBy (keySelector, resultSelector, porównywarka)
• ParallelEnumerable.GroupBy (keySelector, elementSelector, rulesSelector)
• ParallelEnumerable.GroupBy (keySelector, elementSelector, rulesSelector, porównywarka)
• ParallelEnumerable.GroupJoin (inner, outerKeySelector, innerKeySelector, resultSelector)
• ParallelEnumerable.GroupJoin (inner, outerKeySelector, innerKeySelector, resultSelector, porównywarka)
• ParallelEnumerable.Intersect (drugi)
• ParallelEnumerable.Intersect (drugi, moduł porównujący)
• ParallelEnumerable.Join (inner, outerKeySelector, innerKeySelector, resultSelector)
• ParallelEnumerable.Join (inner, outerKeySelector, innerKeySelector, resultSelector, porównywarka)
• ParallelEnumerable.Last ()
• ParallelEnumerable.Last (predicate)
• ParallelEnumerable.LastOrDefault ()
• ParallelEnumerable.LastOrDefault (predykat)
• ParallelEnumerable.LongCount ()
• ParallelEnumerable.LongCount (predicate)
• ParallelEnumerable.Max ()
• ParallelEnumerable.Max (selektor)
• ParallelEnumerable.Min ()
• ParallelEnumerable.Min (selektor)
• ParallelEnumerable.OfType ()
• ParallelEnumerable.OrderBy (keySelector)
• ParallelEnumerable.OrderBy (keySelector, porównywarka)
• ParallelEnumerable.OrderByDescending (keySelector)
• ParallelEnumerable.OrderByDescending (keySelector, porównywarka)
• ParallelEnumerable.Range (start, count)
• ParallelEnumerable.Repeat (element, liczba)
• ParallelEnumerable.Reverse ()
• ParallelEnumerable.Select (selektor)
• ParallelEnumerable.SelectMany (selektor)
• ParallelEnumerable.SelectMany (collectionSelector, resultSelector)
• ParallelEnumerable.SequenceEqual (drugi)
• ParallelEnumerable.SequenceEqual (drugi, moduł porównujący)
• ParallelEnumerable.Single ()
• ParallelEnumerable.Single (predykat)
• ParallelEnumerable.SingleOrDefault ()
• ParallelEnumerable.SingleOrDefault (predykat)
• ParallelEnumerable.Skip (liczba)
• ParallelEnumerable.SkipWhile (predicate)
• ParallelEnumerable.Sum ()
• ParallelEnumerable.Sum (selektor)
• ParallelEnumerable.Take (count)
• ParallelEnumerable.TakeWhile (predicate)
• ParallelEnumerable.ThenBy (keySelector)
• ParallelEnumerable.ThenBy (keySelector, porównywarka)
• ParallelEnumerable.ThenByDescending (keySelector)
• ParallelEnumerable.ThenByDescending (keySelector, porównywarka)
• ParallelEnumerable.ToArray ()
• ParallelEnumerable.ToDictionary (keySelector)
• ParallelEnumerable.ToDictionary (keySelector, porównywarka)
• ParallelEnumerable.ToDictionary (elementSelector)
• ParallelEnumerable.ToDictionary (elementSelector, porównywarka)
• ParallelEnumerable.ToList ()
• ParallelEnumerable.ToLookup (keySelector)
• ParallelEnumerable.ToLookup (keySelector, porównywarka)
• ParallelEnumerable.ToLookup (keySelector, elementSelector)
• ParallelEnumerable.ToLookup (keySelector, elementSelector, porównywarka)
• ParallelEnumerable.Union (drugi)
• ParallelEnumerable.Union (drugi, moduł porównujący)
• ParallelEnumerable.Where (predicate)
• ParallelEnumerable.WithCancellation (cancellationToken)
• ParallelEnumerable.WithDegreeOfParallelism (degreeOfParallelism)
• ParallelEnumerable.WithExecutionMode (executeMode)
• ParallelEnumerable.WithMergeOptions (mergeOptions)
• ParallelEnumerable.Zip (second, resultSelector)

Prosty przykład

Ten przykład pokazuje, jak PLINQ można wykorzystać do obliczenia liczb parzystych od 1 do 10 000 przy użyciu wielu wątków. Pamiętaj, że wynikowa lista nie zostanie zamówiona!

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

Stopień równoległości to maksymalna liczba jednocześnie wykonujących się zadań, które zostaną wykorzystane do przetworzenia zapytania.

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

Na zamówienie

Ten przykład pokazuje, jak PLINQ można wykorzystać do obliczenia liczb parzystych od 1 do 10 000 przy użyciu wielu wątków. Kolejność zostanie zachowana na wynikowej liście, należy jednak pamiętać, że AsOrdered może AsOrdered wydajność dużej liczby elementów, dlatego w miarę możliwości preferowane jest przetwarzanie AsOrdered .

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

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

AsUnordered

Uporządkowane sekwencje mogą zaszkodzić wydajności, gdy mamy do czynienia z dużą liczbą elementów. Aby to złagodzić, można wywołać AsUnordered gdy kolejność sekwencji nie jest już potrzebna.

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