Différence linq et plinq

MSDN a beaucoup de documents à ce sujet.

LINQ est une collection de technologies qui travaillent ensemble pour résoudre une famille similaire de problèmes - dans tous, vous avez une source de données (fichier XML ou fichiers, contenu de la base de données, collection d'objets en mémoire) et vous souhaitez récupérer certaines ou toutes ces données et agissent d'une certaine manière. LINQ travaille sur le point communalact de cet ensemble de problèmes tels que: xxx pré>

et l'équivalent (utilisation explicite des classes liées à Linq et des procédés avec une syntaxe C # traditionnelle): P>

var birthdays = users
  .Where(user => user.dob.Date == DateTime.Today)
  .Select(user => new{user.Firstname, user.Lastname, user.Email});
foreach(bdUser in birthdays)
  SendBirthdayMail(bdUser.Firstname, bdUser.Lastname, bdUser.Email);

envisager d'éviter types anonymes tandis que Travailler avec PLINQ car selon Filetage en C #, par Joe Albahari :

types anonymes (en cours de cours et donc types de référence) inciter le coût de l'allocation basée sur le tas et la collecte des ordures ultérieures.

(...)

L'allocation basée sur la pile est hautement parallélélisable (comme chaque thread a sa propre pile), tandis que toutes les threads doivent concurrencer le même tas - géré par un seul gestionnaire de mémoire et un collecteur à ordures.

Je voulais aussi savoir quand utiliser Plinq au lieu de Linq, donc j'ai rencontré des tests.

Résumé strong>: Il y a deux questions à répondre lorsque vous décidez d'utiliser LINQ ou PLINQ pour exécuter une requête. P>

1. Combien d'itérations sont impliquées dans la gestion de la requête (combien d'objets sont dans la collection)? P> LI>

2. Combien de travail est impliqué dans une itération? P> LI> ol>

   Utilisez LINQ à moins que Plinq soit plus performant. Plinq peut être plus performant que Linq si interrogeant la collection implique trop d'itérations et / ou chaque itération implique trop de travail. P>

   mais deux questions difficiles surviennent: p>

   1. Combien d'itérations sont trop nombreuses itérations? LI>
   2. Combien de travail est trop travail? LI> ol>

      Mon conseil est de Testez votre requête forte>. Testez une fois à l'aide de Linq et une fois en utilisant Plinq, puis comparez les deux résultats. P>

      Test 1: Augmenter le nombre d'itérations dans la requête en augmentant le nombre d'objets dans la collection. Strong> P>

      La surcharge de l'initialisation Plinq prend environ 20 ms. Si les forces de PLINQ ne sont pas utilisées, ceci est gaspillé du temps car Linq a une surcharge 0 ms. P>

      Le travail impliqué dans chaque itération est toujours le même pour chaque test. Le travail est maintenu minimal. P>

      Définition du travail strong>: multiplier l'int (objet dans la collection) par 10. p>

      Lorsque vous itérant 1 million d'objets où L'itération implique un travail minimal, Plinq est plus rapide que Linq. Bien que dans un environnement professionnel, je n'ai jamais interrogé ou même initialement initialisé une collection de 10 millions d'objets en mémoire, ce qui pourrait être un scénario improbable, où plinq est supérieur à LINQ. P>

      class Program
      {
          private static IEnumerable<int> _numbers;
      
          static void Main(string[] args)
          {
              _numbers = Enumerable.Range(0, 10);
      
              var watch = new Stopwatch();
      
              watch.Start();
      
              var parallelTask = Task.Run(() => ParallelTask());
      
              parallelTask.Wait();
      
              watch.Stop();
      
              Console.WriteLine($"Parallel: {watch.ElapsedMilliseconds}ms");
      
              watch.Reset();
      
              watch.Start();
      
              var sequentialTask = Task.Run(() => SequentialTask());
      
              sequentialTask.Wait();
      
              watch.Stop();
      
              Console.WriteLine($"Sequential: {watch.ElapsedMilliseconds}ms");
      
              Console.ReadKey();
          }
      
          private static void ParallelTask()
          {
              _numbers
                  .AsParallel()
                  .Select(x => DoWork(x))
                  .ToArray();
          }
      
          private static void SequentialTask()
          {
              _numbers
                  .Select(x => DoWork(x))
                  .ToArray();
          }
      
          private static int DoWork(int @int)
          {
              const int numberOfIterations = 1000000000;
      
              for (int i = 0; i < numberOfIterations; i++)
              {
                  @int = @int * 10;
              }
      
              return @int;
          }
      }
      

plinq peut augmenter considérablement la vitesse de LINQ vers des requêtes d'objets en utilisant plus efficacement tous les cœurs disponibles sur l'ordinateur hôte. Cette performance accrue apporte une puissance de calcul de haute performance sur le bureau.