C# Language
Ausdrucksbäume

Einführung

Syntax

• Ausdruck <TDelegate> name = lambdaExpression;

Parameter

Bemerkungen

Erstellen von Ausdrucksbäumen mithilfe der 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 });

Ausdrucksbäume kompilieren

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

Analysieren von Ausdrucksbäumen

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      

Erstellen Sie Ausdrucksbäume mit einem Lambda-Ausdruck

Es folgt der grundlegendste Ausdrucksbaum, der von Lambda erstellt wird.

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

Um Ausdrucksbäume "von Hand" zu erstellen, sollte man die Expression Klasse verwenden.

Der obige Ausdruck wäre äquivalent zu:

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

Grundlegendes zur API für Ausdrücke

Wir werden die Ausdrucksstruktur-API verwenden, um eine CalculateSalesTax Struktur zu erstellen. Im Klartext finden Sie hier eine Zusammenfassung der Schritte, die zum Erstellen des Baums erforderlich sind.

1. Prüfen Sie, ob das Produkt steuerpflichtig ist
2. Ist dies der Fall, multiplizieren Sie die Zeilensumme mit dem anwendbaren Steuersatz und geben Sie diesen Betrag zurück
3. Ansonsten 0 zurückgeben

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

Ausdrucksbaum Basic

Ausdrucksbäume repräsentieren Code in einer baumartigen Datenstruktur, wobei jeder Knoten ein Ausdruck ist

Expression Trees ermöglicht die dynamische Änderung von ausführbarem Code, die Ausführung von LINQ-Abfragen in verschiedenen Datenbanken und die Erstellung dynamischer Abfragen. Sie können Code, der durch Ausdrucksbäume dargestellt wird, kompilieren und ausführen.

Diese werden auch in der Dynamic Language Run-Time (DLR) verwendet, um Interoperabilität zwischen dynamischen Sprachen und .NET Framework bereitzustellen und Compiler-Autoren zu ermöglichen, Ausdrucksbäume anstelle von Microsoft Intermediate Language (MSIL) auszugeben.

Ausdrucksbäume können über erstellt werden

1. Anonymer Lambda-Ausdruck,
2. Manuell unter Verwendung des System.Linq.Expressions-Namespace.

Ausdrucksbäume aus Lambda-Ausdrücken

Wenn der Ausdruckstypvariable ein Lambda-Ausdruck zugewiesen wird, gibt der Compiler Code aus, um einen Ausdrucksbaum zu erstellen, der den Lambda-Ausdruck darstellt.

Die folgenden Codebeispiele zeigen, wie der C # -Compiler eine Ausdrucksbaumstruktur erstellt, die den Lambda-Ausdruck num => num <5 darstellt.

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

Ausdrucksbäume mithilfe der API

Ausdrucksbäume werden auch mit der Ausdrucksklasse erstellt . Diese Klasse enthält statische Factory-Methoden, die Ausdrucksstrukturknoten bestimmter Typen erstellen.

Nachfolgend finden Sie einige Baumknoten.

1. ParameterExpression
2. MethodCallExpression

Das folgende Codebeispiel zeigt, wie Sie mithilfe der API eine Ausdrucksbaumstruktur erstellen, die den Lambda-Ausdruck num => num <5 darstellt.

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

Untersuchung der Struktur eines Ausdrucks mithilfe von Besucher

Definieren Sie eine neue Besucherklasse, indem Sie einige der Methoden von ExpressionVisitor überschreiben:

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

Rufen Sie Visit an, um diesen Besucher für einen vorhandenen Ausdruck zu verwenden:

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