C# Language
Alberi di espressione

introduzione

Sintassi

• Espressione <TDelegate> name = lambdaExpression;

Parametri

Osservazioni

Creazione di alberi di espressione mediante 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 });

Compilazione degli alberi di espressione

// 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));

Parsing Expression Trees

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      

Crea alberi espressione con un'espressione lambda

Di seguito è riportato l'albero delle espressioni di base creato da lambda.

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

Per creare alberi di espressioni 'a mano', si dovrebbe usare la classe Expression .

L'espressione sopra sarebbe equivalente a:

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);

Comprendere l'API delle espressioni

Utilizzeremo l'albero delle espressioni API per creare un albero CalculateSalesTax . In inglese semplice, ecco un riepilogo dei passaggi necessari per creare l'albero.

1. Controlla se il prodotto è tassabile
2. Se lo è, moltiplica la linea totale per l'aliquota fiscale applicabile e restituisci tale importo
3. Altrimenti restituisci 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);

Expression Tree Basic

Gli alberi di espressione rappresentano il codice in una struttura dati ad albero, in cui ogni nodo è un'espressione

Expression Trees consente la modifica dinamica del codice eseguibile, l'esecuzione di query LINQ in vari database e la creazione di query dinamiche. È possibile compilare ed eseguire codice rappresentato da alberi di espressione.

Questi vengono anche utilizzati nel linguaggio dinamico run-time (DLR) per fornire l'interoperabilità tra i linguaggi dinamici e .NET Framework e per consentire ai produttori di compilatori di emettere alberi di espressioni anziché il linguaggio intermedio Microsoft (MSIL).

Gli alberi di espressione possono essere creati tramite

1. Espressione lambda anonima,
2. Manualmente utilizzando lo spazio dei nomi System.Linq.Expressions.

Expression Trees from Lambda Expressions

Quando un'espressione lambda viene assegnata alla variabile di tipo Expression, il compilatore emette il codice per creare un albero di espressioni che rappresenti l'espressione lambda.

I seguenti esempi di codice mostrano come fare in modo che il compilatore C # crei un albero di espressioni che rappresenti l'espressione lambda num => num <5.

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

Alberi di espressione utilizzando l'API

Alberi di espressione creati anche usando la classe di espressione . Questa classe contiene metodi factory statici che creano nodi di albero dell'espressione di tipi specifici.

Di seguito sono riportati alcuni tipi di nodi Tree.

1. ParameterExpression
2. MethodCallExpression

Il seguente esempio di codice mostra come creare un albero di espressioni che rappresenti l'espressione lambda num => num <5 utilizzando 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 });

Esaminando la struttura di un'espressione usando Visitor

Definisci una nuova classe di visitatori sovrascrivendo alcuni dei metodi di 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);
    }
}

Chiama Visit per utilizzare questo visitatore su un'espressione esistente:

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