Une instruction LINQ est-elle plus rapide qu'une boucle «foreach»?

J'écris un gestionnaire de rendu de maillage et j'ai pensé que ce serait une bonne idée de regrouper tous les maillages qui utilisent le même shader, puis de les rendre pendant que je suis dans cette passe de shader.

J'utilise actuellement une foreachboucle, mais je me suis demandé si l'utilisation de LINQ pouvait me permettre d'augmenter les performances?

Pourquoi LINQ devrait-il être plus rapide? Il utilise également des boucles en interne.

La plupart du temps, LINQ sera un peu plus lent car il introduit une surcharge. N'utilisez pas LINQ si vous vous souciez beaucoup des performances. Utilisez LINQ car vous voulez un code plus court, mieux lisible et maintenable.

LINQ-to-Objects va généralement ajouter des frais généraux marginaux (itérateurs multiples, etc.). Il doit encore faire les boucles, et a délégué invoque, et devra généralement faire un peu plus pour obtenir le déréférencement à des variables capturées , etc. Dans la plupart des codes ce sera pratiquement indétectable, et plus offert par le plus simple à comprendre le code.

Avec d'autres fournisseurs LINQ comme LINQ-to-SQL, puisque la requête peut filtrer sur le serveur, elle devrait être bien meilleure qu'un flat foreach, mais vous n'auriez probablement pas fait une couverture de "select * from foo" toute façon , donc ce n'est pas nécessairement juste Comparaison.

Re PLINQ; le parallélisme peut réduire le temps écoulé , mais le temps CPU total augmentera généralement un peu en raison des frais généraux de la gestion des threads, etc.

Je pense que LINQ est préférable d'utiliser sur une foreachboucle, car il vous donne un code beaucoup plus propre et facile à comprendre. Mais LINQ est plus lent que foreach. Pour en savoir plus, consultez l'article LINQ vs FOREACH vs FOR Loop Performance .

LINQ est plus lent maintenant, mais il pourrait devenir plus rapide à un moment donné. L'avantage de LINQ est que vous n'avez pas à vous soucier de son fonctionnement. Si une nouvelle méthode est imaginée et incroyablement rapide, les gens de Microsoft peuvent l'implémenter sans même vous le dire et votre code serait beaucoup plus rapide.

Plus important encore, LINQ est simplement beaucoup plus facile à lire. Cela devrait être une raison suffisante.

Il faut probablement noter que la forboucle est plus rapide que le foreach. Donc, pour le message d'origine, si vous vous inquiétez des performances sur un composant critique comme un moteur de rendu, utilisez une forboucle.

Référence: Dans .NET, quelle boucle s'exécute plus rapidement, «for» ou «foreach»?

Vous pouvez obtenir une amélioration des performances si vous utilisez LINQ parallèle pour plusieurs cœurs. Voir Parallel LINQ (PLINQ) (MSDN).

J'étais intéressé par cette question, alors j'ai fait un test tout à l'heure. Utilisation de .NET Framework 4.5.2 sur un processeur Intel (R) Core (TM) i3-2328M à 2,20 GHz, 2200 Mhz, 2 cœurs avec 8 Go de RAM exécutant Microsoft Windows 7 Ultimate.

Il semble que LINQ soit plus rapide que pour chaque boucle. Voici les résultats que j'ai obtenus:

Exists = True
Time   = 174
Exists = True
Time   = 149

Il serait intéressant que certains d'entre vous puissent copier et coller ce code dans une application console et le tester également. Avant de tester avec un objet (Employee), j'ai essayé le même test avec des entiers. LINQ y était également plus rapide.

public class Program
{
    public class Employee
    {
        public int id;
        public string name;
        public string lastname;
        public DateTime dateOfBirth;

        public Employee(int id,string name,string lastname,DateTime dateOfBirth)
        {
            this.id = id;
            this.name = name;
            this.lastname = lastname;
            this.dateOfBirth = dateOfBirth;

        }
    }

    public static void Main() => StartObjTest();

    #region object test

    public static void StartObjTest()
    {
        List<Employee> items = new List<Employee>();

        for (int i = 0; i < 10000000; i++)
        {
            items.Add(new Employee(i,"name" + i,"lastname" + i,DateTime.Today));
        }

        Test3(items, items.Count-100);
        Test4(items, items.Count - 100);

        Console.Read();
    }


    public static void Test3(List<Employee> items, int idToCheck)
    {

        Stopwatch s = new Stopwatch();
        s.Start();

        bool exists = false;
        foreach (var item in items)
        {
            if (item.id == idToCheck)
            {
                exists = true;
                break;
            }
        }

        Console.WriteLine("Exists=" + exists);
        Console.WriteLine("Time=" + s.ElapsedMilliseconds);

    }

    public static void Test4(List<Employee> items, int idToCheck)
    {

        Stopwatch s = new Stopwatch();
        s.Start();

        bool exists = items.Exists(e => e.id == idToCheck);

        Console.WriteLine("Exists=" + exists);
        Console.WriteLine("Time=" + s.ElapsedMilliseconds);

    }

    #endregion


    #region int test
    public static void StartIntTest()
    {
        List<int> items = new List<int>();

        for (int i = 0; i < 10000000; i++)
        {
            items.Add(i);
        }

        Test1(items, -100);
        Test2(items, -100);

        Console.Read();
    }

    public static void Test1(List<int> items,int itemToCheck)
    {

        Stopwatch s = new Stopwatch();
        s.Start();

        bool exists = false;
        foreach (var item in items)
        {
            if (item == itemToCheck)
            {
                exists = true;
                break;
            }
        }

        Console.WriteLine("Exists=" + exists);
        Console.WriteLine("Time=" + s.ElapsedMilliseconds);

    }

    public static void Test2(List<int> items, int itemToCheck)
    {

        Stopwatch s = new Stopwatch();
        s.Start();

        bool exists = items.Contains(itemToCheck);

        Console.WriteLine("Exists=" + exists);
        Console.WriteLine("Time=" + s.ElapsedMilliseconds);

    }

    #endregion

}

C'est en fait une question assez complexe. Linq rend certaines choses très faciles à faire, que si vous les implémentez vous-même, vous pourriez trébucher (par exemple, linq .Except ()). Ceci s'applique en particulier à PLinq, et en particulier à l'agrégation parallèle implémentée par PLinq.

En général, pour un code identique, linq sera plus lent, en raison de la surcharge de l'appel de délégué.

Si, cependant, vous traitez un large éventail de données et appliquez des calculs relativement simples aux éléments, vous obtiendrez une augmentation considérable des performances si:

1. Vous utilisez un tableau pour stocker les données.

2. Vous utilisez une boucle for pour accéder à chaque élément (par opposition à foreach ou linq).

   • Remarque: lors de l'analyse comparative, rappelez-vous - si vous utilisez le même tableau / liste pour deux tests consécutifs, le cache du processeur accélérera le second. *