C# Language
Uitdrukkingsbomen

Invoering

Syntaxis

• Expression <TDelegate> name = lambdaExpression;

parameters

Opmerkingen

Expressiebomen maken met behulp van de 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 });

Het samenstellen van expressiebomen

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

Bomen met expressie ontleden

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      

Maak expressiebomen met een lambda-expressie

Hierna volgt de meest basale expressieboom die is gemaakt door lambda.

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

Om expressiebomen met de hand te maken, moet men de klasse Expression gebruiken.

Bovenstaande uitdrukking zou gelijk zijn aan:

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

Inzicht in de API voor uitdrukkingen

We gaan de expressieboom-API gebruiken om een CalculateSalesTax boom te maken. In gewoon Engels, hier is een samenvatting van de stappen die het neemt om de boom te maken.

1. Controleer of het product belastbaar is
2. Als dit het geval is, vermenigvuldigt u het regeltotaal met het toepasselijke belastingtarief en geeft u dat bedrag terug
3. Anders terug 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

Expressiebomen vertegenwoordigen code in een boomachtige gegevensstructuur, waarbij elk knooppunt een expressie is

Expression Trees maakt dynamische aanpassing van uitvoerbare code, het uitvoeren van LINQ-query's in verschillende databases en het maken van dynamische query's mogelijk. U kunt code compileren en uitvoeren die wordt weergegeven door expressiebomen.

Deze worden ook gebruikt in de dynamische taal runtime (DLR) om interoperabiliteit te bieden tussen dynamische talen en het .NET Framework en om compileerschrijvers in staat te stellen expressiebomen uit te stoten in plaats van Microsoft intermediaire taal (MSIL).

Expressiebomen kunnen worden gemaakt via

1. Anonieme lambda-uitdrukking,
2. Handmatig met de naamruimte System.Linq.Expressions.

Uitdrukkingsbomen van Lambda-uitdrukkingen

Wanneer een lambda-expressie wordt toegewezen aan de variabele Expression type, zendt de compiler code uit om een expression tree op te bouwen die de lambda-expressie vertegenwoordigt.

De volgende codevoorbeelden laten zien hoe de C # compiler een expressiestructuur moet maken die de lambda-expressie num => num <5 vertegenwoordigt.

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

Expressiebomen met behulp van de API

Expression Trees ook gemaakt met behulp van de Expression Class. Deze klasse bevat statische fabrieksmethoden die expressiestructuurknooppunten van specifieke typen maken.

Hieronder staan enkele soorten boomknooppunten.

1. ParameterExpression
2. MethodCallExpression

Het volgende codevoorbeeld laat zien hoe u een expressieboom kunt maken die de lambda-expressie num => num <5 vertegenwoordigt met behulp van de 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 });

De structuur van een expressie onderzoeken met bezoeker

Definieer een nieuwe bezoekersklasse door een aantal methoden van ExpressionVisitor te overschrijven:

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

Visit om deze bezoeker op een bestaande uitdrukking te gebruiken:

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