C# Language
समानांतर LINQ (PLINQ)

.NET Framework ASP.NET asp.net-mvc Entity Framework JavaScript Regular Expressions SQL Microsoft SQL Server unity3d wpf
खोज…


वाक्य - विन्यास

  • ParallelEnumerable.Aggregate (समारोह)
  • ParallelEnumerable.Aggregate (बीज, दुर्गंध)
  • ParallelEnumerable.Aggregate (बीज, अद्यतनअनुसूचक यंत्र ,cc, संयुक्ताक्षरों का जमाव, परिणामक)
  • ParallelEnumerable.Aggregate (seedFactory, updateAccumulatorFunc, CombAccumulatorsFunc, resultSelector)
  • ParallelEnumerable.All (विधेय)
  • ParallelEnumerable.Any ()
  • ParallelEnumerable.Any (विधेय)
  • ParallelEnumerable.AsEnumerable ()
  • ParallelEnumerable.AsOrdered ()
  • ParallelEnumerable.AsParallel ()
  • ParallelEnumerable.AsSequential ()
  • ParallelEnumerable.AsUnordered ()
  • ParallelEnumerable.Average (चयनकर्ता)
  • ParallelEnumerable.Cast ()
  • ParallelEnumerable.Concat (दूसरा)
  • ParallelEnumerable.Contains (मान)
  • ParallelEnumerable.Contains (मान, तुलना)
  • ParallelEnumerable.Count ()
  • ParallelEnumerable.Count (विधेय)
  • ParallelEnumerable.DefaultIfEmpty ()
  • ParallelEnumerable.DefaultIfEmpty (DefaultValue)
  • ParallelEnumerable.Distinct ()
  • ParallelEnumerable.Distinct (comparer)
  • ParallelEnumerable.ElementAt (इंडेक्स)
  • ParallelEnumerable.ElementAtOrDefault (इंडेक्स)
  • ParallelEnumerable.Empty ()
  • ParallelEnumerable.Except (दूसरा)
  • ParallelEnumerable.Except (दूसरा, तुलना)
  • ParallelEnumerable.First ()
  • ParallelEnumerable.First (विधेय)
  • ParallelEnumerable.FirstOrDefault ()
  • ParallelEnumerable.FirstOrDefault (विधेय)
  • ParallelEnumerable.ForAll (कार्रवाई)
  • ParallelEnumerable.GroupBy (keySelector)
  • ParallelEnumerable.GroupBy (keySelector, तुलनित्र)
  • ParallelEnumerable.GroupBy (keySelector, elementSelector)
  • ParallelEnumerable.GroupBy (keySelector, elementSelector, तुलनित्र)
  • ParallelEnumerable.GroupBy (keySelector, resultSelector)
  • ParallelEnumerable.GroupBy (keySelector, resultSelector, तुलनित्र)
  • ParallelEnumerable.GroupBy (keySelector, elementSelector, ruleSelector)
  • ParallelEnumerable.GroupBy (keySelector, elementSelector, ruleSelector, तुलनित्र)
  • ParallelEnumerable.GroupJoin (आंतरिक, आउटरकीलर, इनरकेयलेक्टर, रिजल्ट सेटर)
  • ParallelEnumerable.GroupJoin (आंतरिक, आउटरकीलर, इनरकेयलेक्टर, परिणामस्वरुप, तुलनित्र)
  • ParallelEnumerable.Intersect (दूसरा)
  • ParallelEnumerable.Intersect (दूसरा, तुलना)
  • ParallelEnumerable.Join (भीतरी, आउटरकीलर, इनरकेयलेक्टर, रिजल्टइंटर)
  • ParallelEnumerable.Join (इनर, आउटरकेयलेक्टर, इनरकेयलेक्टर, रिजल्टसेंटर, तुलनित्र)
  • ParallelEnumerable.Last ()
  • ParallelEnumerable.Last (विधेय)
  • ParallelEnumerable.LastOrDefault ()
  • ParallelEnumerable.LastOrDefault (विधेय)
  • ParallelEnumerable.LongCount ()
  • ParallelEnumerable.LongCount (विधेय)
  • ParallelEnumerable.Max ()
  • ParallelEnumerable.Max (चयनकर्ता)
  • ParallelEnumerable.Min ()
  • ParallelEnumerable.Min (चयनकर्ता)
  • ParallelEnumerable.OfType ()
  • ParallelEnumerable.OrderBy (keySelector)
  • ParallelEnumerable.OrderBy (keySelector, तुलनित्र)
  • ParallelEnumerable.OrderByDescending (keySelector)
  • ParallelEnumerable.OrderByDescending (keySelector, तुलनित्र)
  • ParallelEnumerable.Range (शुरू, गिनती)
  • ParallelEnumerable.Repeat (तत्व, गणना)
  • ParallelEnumerable.Reverse ()
  • ParallelEnumerable.Select (चयनकर्ता)
  • ParallelEnumerable.SelectMany (चयनकर्ता)
  • ParallelEnumerable.SelectMany (संग्रहकार्यकर्ता, परिणामकर्ता)
  • ParallelEnumerable.SequenceEqual (दूसरा)
  • ParallelEnumerable.SequenceEqual (दूसरा, तुलनित्र)
  • ParallelEnumerable.Single ()
  • ParallelEnumerable.Single (विधेय)
  • ParallelEnumerable.SingleOrDefault ()
  • ParallelEnumerable.SingleOrDefault (विधेय)
  • ParallelEnumerable.Skip (संख्या)
  • ParallelEnumerable.SkipWhile (विधेय)
  • ParallelEnumerable.Sum ()
  • ParallelEnumerable.Sum (चयनकर्ता)
  • ParallelEnumerable.Take (संख्या)
  • ParallelEnumerable.TakeWhile (विधेय)
  • ParallelEnumerable.ThenBy (keySelector)
  • ParallelEnumerable.ThenBy (keySelector, तुलनित्र)
  • ParallelEnumerable.ThenByDescending (keySelector)
  • ParallelEnumerable.ThenByDescending (keySelector, तुलना करने वाला)
  • ParallelEnumerable.ToArray ()
  • ParallelEnumerable.ToDictionary (keySelector)
  • ParallelEnumerable.ToDictionary (keySelector, तुलनित्र)
  • ParallelEnumerable.ToDictionary (elementSelector)
  • ParallelEnumerable.ToDictionary (एलिमेंटसएक्टर, तुलनित्र)
  • ParallelEnumerable.ToList ()
  • ParallelEnumerable.ToLookup (keySelector)
  • ParallelEnumerable.ToLookup (keySelector, तुलनित्र)
  • ParallelEnumerable.ToLookup (keySelector, elementSelector)
  • ParallelEnumerable.ToLookup (keySelector, elementSelector, तुलना करने वाला)
  • ParallelEnumerable.Union (दूसरा)
  • ParallelEnumerable.Union (दूसरा, तुलना)
  • ParallelEnumerable.Where (विधेय)
  • ParallelEnumerable.WithCancellation (cancellationToken)
  • ParallelEnumerable.WithDegreeOfParallelism (degreeOfParallelism)
  • ParallelEnumerable.WithExecutionMode (executionMode)
  • ParallelEnumerable.WithMergeOptions (mergeOptions)
  • ParallelEnumerable.Zip (दूसरा, परिणामकर्ता)

सरल उदाहरण है

यह उदाहरण दिखाता है कि PLINQ का उपयोग कई थ्रेड्स का उपयोग करके 1 और 10,000 के बीच की संख्याओं की गणना करने के लिए कैसे किया जा सकता है। ध्यान दें कि परिणामी सूची का आदेश नहीं दिया जाएगा! 

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

समानता की डिग्री समवर्ती निष्पादित कार्यों की अधिकतम संख्या है जो क्वेरी को संसाधित करने के लिए उपयोग की जाएगी। 

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

AsOrdered

यह उदाहरण दिखाता है कि PLINQ का उपयोग कई थ्रेड्स का उपयोग करके 1 और 10,000 के बीच की संख्याओं की गणना करने के लिए कैसे किया जा सकता है। परिणामी सूची में आदेश बनाए रखा जाएगा, हालांकि ध्यान रखें कि AsOrdered तत्वों की एक बड़ी संख्या के लिए प्रदर्शन को नुकसान 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

बड़ी संख्या में तत्वों के साथ काम करते समय क्रमबद्ध अनुक्रम प्रदर्शन को नुकसान पहुंचा सकते हैं। इसे कम करने के लिए, जब क्रम क्रम आवश्यक नहीं रह जाता है, तो AsUnordered कॉल करना संभव है। 

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


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow