C# Language
Arboles de expresion

Introducción

Sintaxis

• Expresión <TDelegate> name = lambdaExpression;

Parámetros

Observaciones

Creando árboles de expresiones usando la 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 });

Compilando arboles de expresion

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

Análisis de árboles de expresión

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      

Crear árboles de expresión con una expresión lambda

A continuación se muestra el árbol de expresiones más básico creado por lambda.

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

Para crear árboles de expresión 'a mano', se debe usar Expression clase de Expression .

La expresión anterior sería 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);

Entendiendo la API de expresiones

Vamos a utilizar la API del árbol de expresiones para crear un árbol CalculateSalesTax . En un lenguaje sencillo, aquí hay un resumen de los pasos necesarios para crear el árbol.

1. Compruebe si el producto está sujeto a impuestos.
2. Si es así, multiplique el total de la línea por la tasa de impuesto aplicable y devuelva esa cantidad
3. De lo contrario devuelve 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);

Árbol de Expresión Básico

Los árboles de expresión representan el código en una estructura de datos similar a un árbol, donde cada nodo es una expresión

Expression Trees permite la modificación dinámica del código ejecutable, la ejecución de consultas LINQ en varias bases de datos y la creación de consultas dinámicas. Puedes compilar y ejecutar código representado por árboles de expresión.

También se usan en el tiempo de ejecución del lenguaje dinámico (DLR) para proporcionar interoperabilidad entre los lenguajes dinámicos y .NET Framework y para permitir que los escritores de compiladores emitan árboles de expresión en lugar del lenguaje intermedio de Microsoft (MSIL).

Los árboles de expresión se pueden crear a través de

1. Expresión lambda anónima,
2. Manualmente utilizando el espacio de nombres System.Linq.Expressions.

Árboles de expresión de Expresiones Lambda

Cuando se asigna una expresión lambda a la variable de tipo de expresión, el compilador emite código para construir un árbol de expresión que representa la expresión lambda.

Los siguientes ejemplos de código muestran cómo hacer que el compilador de C # cree un árbol de expresión que represente la expresión lambda num => num <5.

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

Árboles de expresión mediante el uso de la API

Los árboles de expresión también se crearon utilizando la clase de expresión . Esta clase contiene métodos de fábrica estáticos que crean nodos de árbol de expresión de tipos específicos.

A continuación se muestran algunos tipos de nodos de árbol.

1. ParameterExpression
2. MethodCallExpression

El siguiente ejemplo de código muestra cómo crear un árbol de expresión que representa la expresión lambda num => num <5 mediante el uso de la 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 });

Examinar la estructura de una expresión usando el visitante

Defina una nueva clase de visitante anulando algunos de los métodos de 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);
    }
}

Llame a Visit para usar este visitante en una expresión existente:

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