18/04/2015 07:21:37 AM

Cộng đồng công nghệ

Cây biểu thức

3.9 CÂY BIỂU THỨC (EXPRESSION TREE)

Cây biểu thức biểu diễn mã dạng cấu trúc cây, trong đó mỗi nốt là một biểu thức, ví dụ một lời gọi phương thức hay một phép toán nhị ngôi như x < y.

Cây biểu thức được sử dụng để tạo truy vấn LINQ (Language-Integrated Query) và DLR (Dynamic Language Runtime) cung cấp tương tác giữa các ngôn ngữ động và nền tảng .NET framework.

Bạn có thể tạo cây biểu thức dựa trên biểu thức Lambda hay tạo thủ công sử dụng không gian tên System.Ling.Expressions.

Tạo cây biểu thức từ biểu thức Lambda

Khi một biểu thức Lambda được gán cho biến kiểu Expression<TDelegate>, trình biên dịch sẽ xây dựng cây biểu thức biểu diễn biểu thức Lambda.

Ví dụ:Tạo cây biểu thức biểu diễn biểu thức Lambda x => x * x

using System.Linq.Expressions;

public delegate int del(int x);

Expression<del> myET = x => x * x;

Tạo cây biểu thức sử dụng API (application programming interface)

Không gian tên System.Ling.Expressions cung cấp lớp Expression chứa các phương thức tĩnh để tạo các nốt của cây biểu thức. Lớp ParameterExpression, biểu diễn một biến hay tham đối, MethodCallExpression biểu diễn lời gọi phương thức.

Ví dụ:Tạo biểu thức cây biểu diễn biểu thức Lambda 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});

Trong .NET Framework 4, cây biểu thức API cũng hỗ trợ biểu thức phép gán và luồng điều khiển như vòng lặp, cấu trúc điều kiện và lệnh try catch. Bằng cách sử dụng API, bạn có thể tạo cây biểu thức phức tạp hơn tạo từ biểu thức Lambda.

Ví dụ:Tạo cây biểu thức tính lũy thừa của một số

// Tạo một biểu thức chứa tham đối

ParameterExpression value = Expression.Parameter(typeof(int), "value");

// Tạo một biểu thức chứa biến cục bộ

ParameterExpression result = Expression.Parameter(typeof(int), "result");

// Tạo một nhãn để nhảy đến từ một vòng lặp

LabelTarget label = Expression.Label(typeof(int));

// Tạo thân phương thức

BlockExpression block = Expression.Block

(

// Bổ sung biến cục bộ

new[] { result },

// Gán hằng đến biến cục bộ

Expression.Assign(result, Expression.Constant(1)),

// Bổ sung vòng lặp

Expression.Loop

(

// Bổ sung khối điều kiện vào vòng lặp

Expression.IfThenElse(

// Điều kiện: value > 1

Expression.GreaterThan(value, Expression.Constant(1)),

// Nếu true: result*=value--, ngược lại thoát vòng lặp và nhảy đến nhãn

Expression.MultiplyAssign(result, Expression.PostDecrementAssign(value)),

Expression.Break(label, result)), label

)

);

//Biên dịch và thực hiện cây biểu thức

int factorial = Expression.Lambda<Func<int, int>>(block, value).Compile()(5);

Console.WriteLine(factorial);

Duyệt cây biểu thức

The following code example demonstrates how the expression tree that represents the lambda expression num => num < 5 (C#) or Function(num) num < 5 (Visual Basic) can be decomposed into its parts.

// Add the following using directive to your code file:

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

// This code produces the following output: