Cộng đồng công nghệ

using System.Linq.Expressions;

public delegate int del(int x);

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

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

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

// 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:

// Decomposed expression: num => num LessThan 5