C# FindAll VS Where Speed ​​

Question

Tout le monde connaît les différences de vitesse entre Where et FindAll on List. Je sais où fait partie de IEnumerable et FindAll fait partie de List, je suis juste curieux de savoir ce qui est le plus rapide.

Answer 1

La méthode FindAll de la classe List <T> classe réellement un nouvel objet de liste et lui ajoute des résultats. La Où méthode d'extension pour IEnumerable <T> simplement itérer sur une liste existante et donne une énumération des résultats correspondants sans créer ou d'ajouter quoi que ce soit (autre que le recenseur lui-même.)

Étant donné un petit ensemble, les deux seraient probablement effectuer de manière comparable. Toutefois, étant donné un ensemble plus important, Where devrait surperformer FindAll, car la nouvelle liste créée pour contenir les résultats devra dynamiquement croître pour contenir des résultats supplémentaires. L'utilisation de la mémoire de FindAll commencera également à croître exponentiellement à mesure qu'augmentera le nombre de résultats correspondants, où l'utilisation de la mémoire devrait être minimale (en excluant tout ce que vous ferez avec les résultats.)

Answer 2

être plus rapide, il profite de déjà connaître la taille de la liste et de boucler à travers le tableau interne avec une simple boucle for. .Where() doit déclencher un énumérateur (une classe de structure scellée appelée WhereIterator dans ce cas) et faire le même travail d'une manière moins spécifique. Cependant, gardez à l'esprit que .Where() est énumérable, ne crée pas activement une liste en mémoire et ne la remplit pas. C'est plus comme un flux, donc l'utilisation de la mémoire sur quelque chose de très grand peut avoir une différence significative. En outre, vous pouvez commencer à utiliser les résultats de manière parallèle beaucoup plus rapidement en utilisant l'approche .Where() en 4.0.

Answer 3

Where est beaucoup, beaucoup plus rapide que FindAll. Peu importe la taille de la liste, Where prend exactement le même temps.

Bien sûr, Where crée simplement une requête. Il ne fait rien, contrairement à FindAll qui crée une liste.

Answer 4

La réponse de jrista fait sens. Cependant, la nouvelle liste ajoute les mêmes objets, augmentant ainsi simplement en référence aux objets existants, ce qui ne devrait pas être si lent. Tant que l'extension 3.5/Linq est possible, Où reste mieux quand même. FindAll a beaucoup plus de sens lorsqu'il est limité à 2.0

Answer 5

FindAll est évidemment plus lent que Where, car il doit créer une nouvelle liste.

Quoi qu'il en soit, je pense que vous devriez vraiment considérer Jon Hanna commentaire - vous aurez probablement besoin de faire quelques opérations sur vos résultats et la liste serait plus utile que IEnumerable dans de nombreux cas.

J'ai écrit un petit test, il suffit de le coller dans le projet Console App. Il mesure le temps/ticks de: l'exécution de la fonction, les opérations sur la collecte des résultats (pour obtenir la représentation de l'utilisation réelle, et pour s'assurer que le compilateur n'optimisera pas les données inutilisées, etc. sachez comment cela fonctionne encore, désolé).

Remarque: chaque fonction mesurée sauf WhereIENumerable() crée une nouvelle liste d'éléments. Je pourrais faire quelque chose de mal, mais clairement IERumerable iterating prend beaucoup plus de temps que la liste iterating.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Diagnostics; 

namespace Tests 
{ 

    public class Dummy 
    { 
     public int Val; 
     public Dummy(int val) 
     { 
      Val = val; 
     } 
    } 
    public class WhereOrFindAll 
    { 
     const int ElCount = 20000000; 
     const int FilterVal =1000; 
     const int MaxVal = 2000; 
     const bool CheckSum = true; // Checks sum of elements in list of resutls 
     static List<Dummy> list = new List<Dummy>(); 
     public delegate void FuncToTest(); 

     public static long TestTicks(FuncToTest function, string msg) 
     { 
      Stopwatch watch = new Stopwatch(); 
      watch.Start(); 
      function(); 
      watch.Stop(); 
      Console.Write("\r\n"+msg + "\t ticks: " + (watch.ElapsedTicks)); 
      return watch.ElapsedTicks; 
     } 
     static void Check(List<Dummy> list) 
     { 
      if (!CheckSum) return; 
      Stopwatch watch = new Stopwatch(); 
      watch.Start(); 

      long res=0; 
      int count = list.Count; 
      for (int i = 0; i < count; i++)  res += list[i].Val; 
      for (int i = 0; i < count; i++)  res -= (long)(list[i].Val * 0.3); 

      watch.Stop(); 
      Console.Write("\r\n\nCheck sum: " + res.ToString() + "\t iteration ticks: " + watch.ElapsedTicks); 
     } 
     static void Check(IEnumerable<Dummy> ieNumerable) 
     { 
      if (!CheckSum) return; 
      Stopwatch watch = new Stopwatch(); 
      watch.Start(); 

      IEnumerator<Dummy> ieNumerator = ieNumerable.GetEnumerator(); 
      long res = 0; 
      while (ieNumerator.MoveNext()) res += ieNumerator.Current.Val; 
      ieNumerator=ieNumerable.GetEnumerator(); 
      while (ieNumerator.MoveNext()) res -= (long)(ieNumerator.Current.Val * 0.3); 

      watch.Stop(); 
      Console.Write("\r\n\nCheck sum: " + res.ToString() + "\t iteration ticks :" + watch.ElapsedTicks); 
     } 
     static void Generate() 
     { 
      if (list.Count > 0) 
       return; 
      var rand = new Random(); 
      for (int i = 0; i < ElCount; i++) 
       list.Add(new Dummy(rand.Next(MaxVal))); 

     } 
     static void For() 
     { 
      List<Dummy> resList = new List<Dummy>(); 
      int count = list.Count; 
      for (int i = 0; i < count; i++) 
      { 
       if (list[i].Val < FilterVal) 
        resList.Add(list[i]); 
      }  
      Check(resList); 
     } 
     static void Foreach() 
     { 
      List<Dummy> resList = new List<Dummy>(); 
      int count = list.Count; 
      foreach (Dummy dummy in list) 
      { 
       if (dummy.Val < FilterVal) 
        resList.Add(dummy); 
      } 
      Check(resList); 
     } 
     static void WhereToList() 
     { 
      List<Dummy> resList = list.Where(x => x.Val < FilterVal).ToList<Dummy>(); 
      Check(resList); 
     } 
     static void WhereIEnumerable() 
     { 
      Stopwatch watch = new Stopwatch(); 
      IEnumerable<Dummy> iEnumerable = list.Where(x => x.Val < FilterVal); 
      Check(iEnumerable); 
     } 
     static void FindAll() 
     { 
      List<Dummy> resList = list.FindAll(x => x.Val < FilterVal); 
      Check(resList); 
     } 
     public static void Run() 
     { 
      Generate(); 
      long[] ticks = { 0, 0, 0, 0, 0 }; 
      for (int i = 0; i < 10; i++) 
      { 
       ticks[0] += TestTicks(For, "For \t\t"); 
       ticks[1] += TestTicks(Foreach, "Foreach \t"); 
       ticks[2] += TestTicks(WhereToList, "Where to list \t"); 
       ticks[3] += TestTicks(WhereIEnumerable, "Where Ienum \t"); 
       ticks[4] += TestTicks(FindAll, "FindAll \t"); 
       Console.Write("\r\n---------------"); 
      } 
      for (int i = 0; i < 5; i++) 
       Console.Write("\r\n"+ticks[i].ToString()); 
     } 

    } 

    class Program 
    { 
     static void Main(string[] args) 
     { 
      WhereOrFindAll.Run(); 
      Console.Read(); 
     } 
    } 
} 

Résultats (tiques) - CheckSum activée (certaines opérations sur les résultats), le mode: libération sans débogage (CTRL + F5):

• 16222276 (pour -> Liste)
• 17151121 (foreach -> liste)
• 4741494 (où -> liste)
• 27122285 (où -> ienum)
• 18 821571 (findall -> Liste)

CheckSum désactivé (ne pas utiliser la liste de retour du tout):

• 10885004 (pour -> Liste)
• 11221888 (foreach -> Liste)
• 18688433 (où -> liste)
• 1075 (où -> ienum)
• 13720243 (findall -> liste)

Vos résultats peuvent être légèrement différents, pour obtenir des résultats réels, vous avez besoin de plus d'itérations.