Par exemple, pourquoi la plupart des opérateurs LINQ acceptent-ils Expression<Func<TSource>>
et son équivalent Func<TSource>
?
Quels sont les avantages / raisons d'utiliser la classe générique Expression
au lieu d'une syntaxe lambda simple?
Par exemple, pourquoi la plupart des opérateurs LINQ acceptent-ils Expression<Func<TSource>>
et son équivalent Func<TSource>
?
Quels sont les avantages / raisons d'utiliser la classe générique Expression
au lieu d'une syntaxe lambda simple?
À l'aide de Expression<T>
vous sont explicitement la création d'une arborescence d'expression , ce qui signifie que vous pouvez traiter avec le code qui fait la requête, comme si il ont été données.
La raison pour cela est que les fournisseurs LINQ (comme LINQ to SQL par exemple) inspecter la requête elle-même afin de déterminer la meilleure façon de traduire les expressions C# dans une requête T-SQL. Depuis une arborescence d'expression vous permet de vérifier le code de données, le fournisseur est en mesure de le faire.
En résumé, les principales différences entre les deux sont les suivantes:
Expression<Func<...>>
est une expression de l'arbre qui représente le code source d'origine (il est stocké dans un arbre comme structure de données qui est très proche de l'original de code C#). Dans ce formulaire, vous pouvez analyser le code source et des outils comme LINQ to SQL peut traduire l'expression de l'arbre (le code source) à d'autres langues (par exemple, SQL en cas de LINQ to SQL, mais vous pouvez également cible ex: JavaScript).
Func<...>
est un délégué ordinaire que vous pouvez exécuter. Dans ce cas, le compilateur compile le corps de la fonction d'intermédiaire de la langue (IL), tout comme lors de la compilation de méthode standard.
Il est important de mentionner que, Expression<..>
a Compile
méthode qui compile l'expression au moment de l'exécution et génère Func<...>
, donc il y a conversion de la première à la seconde (avec quelques performances de coût). Cependant, il n'y a pas de conversion à partir de la seconde à la première, car une fois que vous obtenir IL, il est très difficile (impossible) de reconstituer le code source d'origine.
Func<T>
crée une fonction exécutable.
Expression<Func<T>>
crée un arbre d'expression qui vous permet de travailler avec le code de la fonction en tant que données.
Les arbres d'expression vous permettent d'effectuer des opérations telles que LINQ to SQL et LINQ to XML en générant les appels sous-jacents à partir de votre code .NET.
Un Expression<Func<>>
est la représentation d'une fonction qui doit encore être transformé en code. Un Func<>
est une réelle fonction exécutable. À l'aide de l'ex-permet d'activer l'expression de en fonction au moment où elle est invoquée. Par exemple, avec LINQ to SQL cela permettra de les traduire dans un le code équivalent à l'exécution d'une instruction SQL et de retourner le contenu spécifié. Avec LINQ to objects, il va exécuter du code sur le client à l'aide de la CLR. Un Func<>
est toujours exécuté dans le CLR -- c'est le code de l'exécutable.
Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.