C# Language
Uttrycksträd

Introduktion

Syntax

• Uttryck <Telegat> namn = lambdaExpression;

parametrar

Anmärkningar

Skapa uttrycksträd med API: et

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

Kompilera uttrycksträd

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

Analysera uttrycksträd

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      

Skapa uttrycksträd med ett lambda-uttryck

Följande är det mest grundläggande uttrycksträdet som skapas av lambda.

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

För att skapa uttrycksträd "för hand" bör man använda Expression klassen.

Uttrycket ovan skulle motsvara:

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

Förstå uttryckens API

Vi kommer att använda uttrycket träd API för att skapa ett CalculateSalesTax träd. På vanligt engelska, här är en sammanfattning av stegen som det tar för att skapa trädet.

1. Kontrollera om produkten är beskattningsbar
2. Om så är fallet multiplicerar du linjen totalt med den tillämpliga skattesatsen och returnerar det beloppet
3. I annat fall returnera 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

Uttrycksträd representerar kod i en trädliknande datastruktur, där varje nod är ett uttryck

Expression Trees möjliggör dynamisk modifiering av körbar kod, exekvering av LINQ-frågor i olika databaser och skapande av dynamiska frågor. Du kan sammanställa och köra kod representerad av uttrycksträd.

Dessa används också i den dynamiska språktiden (DLR) för att tillhandahålla interoperabilitet mellan dynamiska språk och .NET Framework och för att göra det möjligt för kompilatorförfattare att avge uttrycksträd istället för Microsofts mellanspråk (MSIL).

Expressionsträd kan skapas via

1. Anonymt lambda-uttryck,
2. Manuellt genom att använda System.Linq.Expressions namnutrymme.

Uttrycksträd från Lambda-uttryck

När ett lambda-uttryck tilldelas variablen Expression-typ avger kompilatorn kod för att bygga ett uttrycksträd som representerar lambda-uttrycket.

Följande kodexempel visar hur C # -kompileraren ska skapa ett uttrycksträd som representerar lambda-uttrycket num => num <5.

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

Uttrycksträd med API: et

Expressionsträd skapade också med hjälp av Expression Class. Den här klassen innehåller statiska fabriksmetoder som skapar uttrycksträdnoder av specifika typer.

Nedan finns få typer av trädnoder.

1. ParameterExpression
2. MethodCallExpression

Följande kodexempel visar hur man skapar ett uttrycksträd som representerar lambda-uttrycket num => num <5 med hjälp av 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 });

Undersöka strukturen för ett uttryck med hjälp av besökare

Definiera en ny besökarklass genom att åsidosätta några av metoderna för 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);
    }
}

Ring Visit att använda den här besökaren på ett befintligt uttryck:

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