Quand comstack-t-on les requêtes de LINQ vers SQL pour améliorer les performances

Je faisais référence à un article qui traite de l’accélération des requêtes LINQ to SQL. L’une des techniques mentionnées est “Utiliser les requêtes compilées” et explique comment l’utiliser.

Je voulais voir l’amélioration des performances des requêtes compilées et par conséquent, j’ai essayé le même exemple fourni par l’auteur. J’ai utilisé Northwind Db comme datacontext. J’ai essayé l’exécution normale et l’exécution comstackdquery et les ai vérifiées sur LINQ PAD.

J’ai d’abord essayé d’exécuter la requête sans utiliser ComstackQuery. Cela a pris 2,065 secondes.

var oo = from o in Orders where o.OrderDetails.Any (p => p.UnitPrice > 100) select o; oo.Dump ("Order items with unit price more than $100"); var oo1 = from o in Orders where o.OrderDetails.Any (p => p.UnitPrice > 10) select o; oo1.Dump ("Order items with unit price more than $10"); 

Deuxièmement, les requêtes avec ComstackQuery. Il a fallu 2.100 secondes.

 var oo = ComstackdQuery.Comstack ((TypedDataContext dc, decimal unitPrice) => from o in Orders where o.OrderDetails.Any (p => p.UnitPrice > unitPrice) select o ); oo (this, 100).Dump ("Order items with unit price more than $100"); oo (this, 10).Dump ("Order items with unit price more than $10"); 

Leur ré-exécution à plusieurs resockets a montré que le temps pris par les deux approches est presque similaire.

Ici, nous ne voyons que deux exécutions de requêtes pour chaque méthode. J’ai essayé de faire 10 requêtes pour chacun d’eux. Mais les deux ont terminé environ 7 secondes.

La pré-compilation des requêtes améliore-t-elle réellement les performances? Ou est-ce que je me trompe en termes d’utilisation?

Merci pour votre temps et votre considération.

Edit: Après avoir lu la réponse acceptée, les lecteurs peuvent également consulter cet article, qui explique en détail comment les requêtes compilées améliorent les performances.

N’oubliez pas qu’il existe deux éléments principaux d’une requête LINQ qui peuvent être particulièrement coûteux:

  1. Comstackr les expressions LINQ dans une instruction SQL.
  2. Exécution de l’instruction SQL et récupération des résultats

Dans votre cas, vous avez une requête relativement simple et une connexion de firebase database très lente, des ensembles de données très volumineux ou des tables non indexées de manière optimale pour exécuter cette requête particulière. Ou peut-être une combinaison des trois.

Donc, comparé au temps nécessaire pour générer le code SQL de votre requête (peut-être 10 à 50 millisecondes), la deuxième étape prend tellement de temps (~ 1000 ms) que vous pouvez à peine remarquer la différence.

Vous verriez des améliorations significatives si les conditions suivantes sont toutes remplies:

  1. votre requête LINQ est complexe,
  2. vous avez une connexion rapide à votre firebase database,
  3. la requête SQL elle-même s’exécute rapidement sur cette firebase database, et
  4. l’ensemble de résultats est suffisamment petit pour qu’il soit transféré assez rapidement de la firebase database.

Dans la pratique, des requêtes pouvant prendre plus de 500 ms ont été compilées, mais quelques millisecondes seulement sont réellement nécessaires. Ce sont généralement les cas où je me concentre sur les requêtes de précompilation.

Un bon moyen de savoir à l’avance quel type de gains de performance vous pouvez attendre des requêtes précompilées consiste à chronométrer la seconde instance de votre requête à l’aide d’un object Stopwatch , puis à exécuter le SQL généré directement à l’aide de la fonction Analyze SQL de LINQPad. Si la requête SQL retourne rapidement mais que la requête LINQ prend beaucoup de temps, c’est un bon candidat pour la précompilation.