C# Language
Arbres d'expression

Introduction

Syntaxe

• Expression <TDelegate> name = lambdaExpression;

Paramètres

Remarques

Création d'arbres d'expression à l'aide de l'API

using System.Linq.Expressions;

// Manually build the expression tree for 
// the lambda expression num => num < 5.
ParameterExpression numParam = Expression.Parameter(typeof(int), "num");
ConstantExpression five = Expression.Constant(5, typeof(int));
BinaryExpression numLessThanFive = Expression.LessThan(numParam, five);
Expression<Func<int, bool>> lambda1 =
    Expression.Lambda<Func<int, bool>>(
        numLessThanFive,
        new ParameterExpression[] { numParam });

Compilation d'arbres d'expression

// Define an expression tree, taking an integer, returning a bool.
Expression<Func<int, bool>> expr = num => num < 5;

// Call the Compile method on the expression tree to return a delegate that can be called.
Func<int, bool> result = expr.Compile();

// Invoke the delegate and write the result to the console.
Console.WriteLine(result(4)); // Prints true

// Prints True.

// You can also combine the compile step with the call/invoke step as below:
Console.WriteLine(expr.Compile()(4));

Analyse d'arbres d'expression

using System.Linq.Expressions;

// Create an expression tree.
Expression<Func<int, bool>> exprTree = num => num < 5;

// Decompose the expression tree.
ParameterExpression param = (ParameterExpression)exprTree.Parameters[0];
BinaryExpression operation = (BinaryExpression)exprTree.Body;
ParameterExpression left = (ParameterExpression)operation.Left;
ConstantExpression right = (ConstantExpression)operation.Right;

Console.WriteLine("Decomposed expression: {0} => {1} {2} {3}",
                  param.Name, left.Name, operation.NodeType, right.Value);

// Decomposed expression: num => num LessThan 5      

Créer des arbres d'expression avec une expression lambda

Voici l'arbre d'expression le plus fondamental créé par lambda.

Expression<Func<int, bool>> lambda = num => num == 42;

Pour créer des arbres d'expression "à la main", il faut utiliser la classe Expression .

L'expression ci-dessus serait équivalente à:

ParameterExpression parameter = Expression.Parameter(typeof(int), "num"); // num argument
ConstantExpression constant = Expression.Constant(42, typeof(int)); // 42 constant
BinaryExpression equality = Expression.Equals(parameter, constant); // equality of two expressions (num == 42)
Expression<Func<int, bool>> lambda = Expression.Lambda<Func<int, bool>>(equality, parameter);

Comprendre l'API des expressions

Nous allons utiliser l'API API pour créer un arbre CalculateSalesTax . En clair, voici un résumé des étapes nécessaires à la création de l'arborescence.

1. Vérifiez si le produit est taxable
2. Si c'est le cas, multipliez le total de la ligne par le taux de taxe applicable et retournez ce montant
3. Sinon retourne 0

//For reference, we're using the API to build this lambda expression
    orderLine => orderLine.IsTaxable ? orderLine.Total * orderLine.Order.TaxRate : 0;

//The orderLine parameter we pass in to the method.  We specify it's type (OrderLine) and the name of the parameter.
    ParameterExpression orderLine = Expression.Parameter(typeof(OrderLine), "orderLine");

//Check if the parameter is taxable;  First we need to access the is taxable property, then check if it's true
    PropertyInfo isTaxableAccessor = typeof(OrderLine).GetProperty("IsTaxable");
    MemberExpression getIsTaxable = Expression.MakeMemberAccess(orderLine, isTaxableAccessor);
    UnaryExpression isLineTaxable = Expression.IsTrue(getIsTaxable);

//Before creating the if, we need to create the braches
    //If the line is taxable, we'll return the total times the tax rate; get the total and tax rate, then multiply
    //Get the total
    PropertyInfo totalAccessor = typeof(OrderLine).GetProperty("Total");
    MemberExpression getTotal = Expression.MakeMemberAccess(orderLine, totalAccessor);
    
    //Get the order
    PropertyInfo orderAccessor = typeof(OrderLine).GetProperty("Order");
    MemberExpression getOrder = Expression.MakeMemberAccess(orderLine, orderAccessor);
    
    //Get the tax rate - notice that we pass the getOrder expression directly to the member access
    PropertyInfo taxRateAccessor = typeof(Order).GetProperty("TaxRate");
    MemberExpression getTaxRate = Expression.MakeMemberAccess(getOrder, taxRateAccessor);
    
    //Multiply the two - notice we pass the two operand expressions directly to multiply
    BinaryExpression multiplyTotalByRate = Expression.Multiply(getTotal, getTaxRate);
    
//If the line is not taxable, we'll return a constant value - 0.0 (decimal)
    ConstantExpression zero = Expression.Constant(0M);

//Create the actual if check and branches
    ConditionalExpression ifTaxableTernary = Expression.Condition(isLineTaxable, multiplyTotalByRate, zero);
    
//Wrap the whole thing up in a "method" - a LambdaExpression
    Expression<Func<OrderLine, decimal>> method = Expression.Lambda<Func<OrderLine, decimal>>(ifTaxableTernary, orderLine);

Arbre d'expression de base

Les arbres d'expression représentent du code dans une structure de données arborescente, où chaque nœud est une expression

Expression Trees permet la modification dynamique du code exécutable, l'exécution de requêtes LINQ dans diverses bases de données et la création de requêtes dynamiques. Vous pouvez compiler et exécuter du code représenté par des arbres d'expression.

Celles-ci sont également utilisées dans le DLR (Dynamic Language Runtime) pour assurer l'interopérabilité entre les langages dynamiques et le .NET Framework et pour permettre aux auteurs du compilateur d'émettre des arborescences d'expression au lieu du langage intermédiaire Microsoft (MSIL).

Des arbres d'expression peuvent être créés via

1. Expression lambda anonyme,
2. Manuellement en utilisant l'espace de noms System.Linq.Expressions.

Arbres d'expression des expressions lambda

Lorsqu'une expression lambda est affectée à une variable de type Expression, le compilateur émet du code pour générer une arborescence d'expression qui représente l'expression lambda.

Les exemples de code suivants montrent comment faire en sorte que le compilateur C # crée un arbre d'expression qui représente l'expression lambda num => num <5.

Expression<Func<int, bool>> lambda = num => num < 5;

Arbres d'expression à l'aide de l'API

Les arbres d'expression ont également été créés à l'aide de la classe d' expression . Cette classe contient des méthodes de fabrique statiques qui créent des nœuds d'arbre d'expression de types spécifiques.

Vous trouverez ci-dessous quelques types de nœuds d'arbre.

1. ParameterExpression
2. MethodCallExpression

L'exemple de code suivant montre comment créer une arborescence d'expression qui représente l'expression lambda num => num <5 en utilisant l'API.

ParameterExpression numParam = Expression.Parameter(typeof(int), "num");
ConstantExpression five = Expression.Constant(5, typeof(int));
BinaryExpression numLessThanFive = Expression.LessThan(numParam, five);
Expression<Func<int, bool>> lambda1 = Expression.Lambda<Func<int, bool>>(numLessThanFive,new ParameterExpression[] { numParam });

Examen de la structure d'une expression à l'aide de Visitor

Définissez une nouvelle classe de visiteur en remplaçant certaines des méthodes d' ExpressionVisitor :

class PrintingVisitor : ExpressionVisitor {
    protected override Expression VisitConstant(ConstantExpression node) {
        Console.WriteLine("Constant: {0}", node);
        return base.VisitConstant(node);
    }
    protected override Expression VisitParameter(ParameterExpression node) {
        Console.WriteLine("Parameter: {0}", node);
        return base.VisitParameter(node);
    }
    protected override Expression VisitBinary(BinaryExpression node) {
        Console.WriteLine("Binary with operator {0}", node.NodeType);
        return base.VisitBinary(node);
    }
}

Appelez Visit pour utiliser ce visiteur sur une expression existante:

Expression<Func<int,bool>> isBig = a => a > 1000000;
var visitor = new PrintingVisitor();
visitor.Visit(isBig);