C# Language
Drzewa ekspresji

Wprowadzenie

Składnia

• Wyrażenie <TDelegate> name = lambdaExpression;

Parametry

Uwagi

Tworzenie drzew wyrażeń za pomocą interfejsu 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 });

Kompilowanie drzew wyrażeń

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

Analizowanie drzew wyrażeń

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      

Utwórz drzewa wyrażeń z wyrażeniem lambda

Poniżej znajduje się najbardziej podstawowe drzewo wyrażeń tworzone przez lambda.

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

Aby ręcznie stworzyć drzewa wyrażeń, należy użyć klasy Expression .

Wyrażenie powyżej byłoby równoważne z:

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

Zrozumienie API wyrażeń

Użyjemy interfejsu API drzewa wyrażeń, aby utworzyć drzewo CalculateSalesTax . Mówiąc wprost, oto podsumowanie kroków, które należy wykonać, aby utworzyć drzewo.

1. Sprawdź, czy produkt podlega opodatkowaniu
2. Jeśli tak, pomnóż sumę wiersza przez obowiązującą stawkę podatkową i zwróć tę kwotę
3. W przeciwnym razie zwróć 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);

Podstawowe drzewo wyrażeń

Drzewa wyrażeń reprezentują kod w drzewiastej strukturze danych, gdzie każdy węzeł jest wyrażeniem

Drzewa wyrażeń umożliwiają dynamiczną modyfikację kodu wykonywalnego, wykonywanie zapytań LINQ w różnych bazach danych oraz tworzenie zapytań dynamicznych. Możesz skompilować i uruchomić kod reprezentowany przez drzewa wyrażeń.

Są one również używane w czasie wykonywania dynamicznego języka (DLR) w celu zapewnienia interoperacyjności między językami dynamicznymi a .NET Framework oraz umożliwienia autorom kompilatorów emitowania drzew wyrażeń zamiast języka pośredniego Microsoft (MSIL).

Drzewa wyrażeń można tworzyć za pośrednictwem

1. Anonimowe wyrażenie lambda,
2. Ręcznie, używając przestrzeni nazw System.Linq.Expressions.

Drzewa wyrażeń z wyrażeń lambda

Gdy wyrażenie lambda jest przypisane do zmiennej typu Expression, kompilator emituje kod, aby zbudować drzewo wyrażeń reprezentujące wyrażenie lambda.

Poniższe przykłady kodu pokazują, w jaki sposób kompilator C # może utworzyć drzewo wyrażeń reprezentujące wyrażenie lambda num => num <5.

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

Drzewa wyrażeń za pomocą interfejsu API

Drzewa wyrażeń utworzono również za pomocą klasy wyrażeń . Ta klasa zawiera statyczne metody fabryczne, które tworzą węzły drzewa wyrażeń określonych typów.

Poniżej kilka rodzajów węzłów drzewa.

1. Wyrażenie parametru
2. MethodCallExpression

Poniższy przykład kodu pokazuje, jak utworzyć drzewo wyrażeń reprezentujące wyrażenie lambda num => num <5 przy użyciu interfejsu 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 });

Badanie struktury wyrażenia za pomocą narzędzia Visitor

Zdefiniuj nową klasę gości, zastępując niektóre metody 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);
    }
}

Zadzwoń do Visit aby użyć tego użytkownika na istniejącym wyrażeniu:

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