.NET Framework Arbre d'expression simple généré par le compilateur C #


Exemple

Considérons le code C # suivant

Expression<Func<int, int>> expression = a => a + 1;

Comme le compilateur C # voit que l'expression lambda est affectée à un type d'expression plutôt qu'à un type délégué, il génère un arbre d'expression à peu près équivalent à ce code

ParameterExpression parameterA = Expression.Parameter(typeof(int), "a");
var expression = (Expression<Func<int, int>>)Expression.Lambda(
                                                 Expression.Add(
                                                     parameterA,
                                                     Expression.Constant(1)),
                                                 parameterA);

La racine de l'arbre est l'expression lambda qui contient un corps et une liste de paramètres. Le lambda a 1 paramètre appelé "a". Le corps est une expression unique du type CLR BinaryExpression et NodeType of Add. Cette expression représente l'addition. Il a deux sous-expressions désignées par Gauche et Droite. Left est l'expression de paramètre pour le paramètre "a" et right est une expression constante avec la valeur 1.

L'utilisation la plus simple de cette expression consiste à l'imprimer:

Console.WriteLine(expression); //prints a => (a + 1)

Qui imprime le code C # équivalent.

L'arbre d'expression peut être compilé en un délégué C # et exécuté par le CLR

Func<int, int> lambda = expression.Compile();
Console.WriteLine(lambda(2)); //prints 3

Habituellement, les expressions sont traduites dans d'autres langages tels que SQL, mais peuvent également être utilisées pour invoquer des membres privés, protégés et internes de types publics ou non publics, en alternative à Reflection.