C# Language
표현식 트리

소개

통사론

• 식 <TDelegate> 이름 = 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 트리를 만들 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);

식 트리 기본

표현 트리는 노드와 같은 데이터 구조의 코드를 나타내며, 각 노드는 표현식입니다.

식 트리를 사용하면 실행 코드의 동적 수정, 다양한 데이터베이스의 LINQ 쿼리 실행 및 동적 쿼리 생성이 가능합니다. 표현식 트리가 나타내는 코드를 컴파일하고 실행할 수 있습니다.

또한 동적 언어 런타임 (DLR)에서 동적 언어와 .NET Framework 간의 상호 운용성을 제공하고 컴파일러 작성자가 Microsoft 중간 언어 (MSIL) 대신 표현식 트리를 내보낼 수있게합니다.

표현식 트리를 통해 만들 수 있음

1. 익명 람다 식,
2. System.Linq.Expressions 네임 스페이스를 사용하여 수동으로.

람다 표현식의 표현식 트리

람다식이 식 유형 변수에 할당되면 컴파일러는 람다 식을 나타내는 식 트리를 작성하는 코드를 내 보냅니다.

다음 코드 예제에서는 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);