C# Language
表現木

前書き

構文

• 式<TDelegate> name = lambdaExpression;

パラメーター

備考

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

式ツリーのコンパイル

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

表現木の解析

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      

ラムダ式による式ツリーの作成

以下は、ラムダによって作成された最も基本的な式ツリーです。

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

'手で'式ツリーを作成するには、 Expressionクラスを使用する必要があります。

上記の式は次のようになります。

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

式APIの理解

式ツリーAPIを使用してCalculateSalesTaxツリーを作成します。簡単な英語で、ツリーの作成に要するステップの概要を以下に示します。

1. 商品が課税対象かどうかを確認する
2. そうであれば、行合計に適用税率を掛けてその金額を返します
3. そうでなければ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 Treesを使用すると、実行可能コードの動的修正、さまざまなデータベースでのLINQクエリの実行、および動的クエリの作成が可能になります。式ツリーで表されるコードをコンパイルして実行することができます。

これらは動的言語ランタイム（DLR）で使用され、動的言語と.NET Framework間の相互運用性を提供し、コンパイラライターがMicrosoft中間言語（MSIL）の代わりに式ツリーを出力できるようにします。

表現木を作成することができます

1. 匿名ラムダ式、
2. 手動でSystem.Linq.Expressions名前空間を使用します。

ラムダ式からの式木

ラムダ式がExpression型変数に代入されると、コンパイラはラムダ式を表す式ツリーを構築するコードを発行します。

次のコード例は、C＃コンパイラがラムダ式num => num <5を表す式ツリーを作成する方法を示しています。

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

APIを使用した表現木

式ツリーは、 式クラスを使用しても作成されます。このクラスには、特定のタイプの式ツリーノードを作成する静的ファクトリメソッドが含まれています。

以下は、いくつかのタイプのツリーノードです。

1. ParameterExpression
2. MethodCallExpression

次のコード例は、APIを使用してラムダ式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 });

ビジターを使って式の構造を調べる

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

既存の表現でこの訪問者を使用するにはVisitを呼び出す：

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