private void Test1()
{
var ParsingExpressionTrees = new ParsingExpressionTrees();
var ParasingExpressionTreeByVisitor = new ParsingExpressionTreeByVisitor();
{
ParameterExpression valueExp = Expression.Parameter(typeof(int), "Value"); //创建参数表达式 Value
ParameterExpression resultExp = Expression.Parameter(typeof(int), "Result"); //创建参数表达式 Result
LabelTarget lableExp = Expression.Label(typeof(int), "Break"); //创建一个标签以从循环跳转到，接收一个int类型的值
BlockExpression blockExp = Expression.Block( //创建代码块
new[] { resultExp } //定义局部变量
, Expression.Assign(resultExp, Expression.Constant(1)) //给变量赋值
, Expression.Loop( //定义循环体
Expression.IfThenElse( //创建条件表达式 if else
Expression.GreaterThanOrEqual(valueExp, Expression.Constant(1)) //valueExp>=1
, Expression.MultiplyAssign(resultExp, Expression.PostDecrementAssign(valueExp)) // if true resultExp*=valueExp--
, Expression.Break(lableExp, resultExp) // if else 跳转到lableExp，并将resultExp传入到跳转到lableExp
)
, lableExp // 跳转到lableExp
)
);
var lambda = Expression.Lambda <Func <int, int> >(blockExp, valueExp);
int value = lambda.Compile().Invoke(6);
WriteLine("{0}:{1}", lambda.Body, value);
WriteLine("lambda:{0}", ParsingExpressionTrees.ParsingExpression(lambda));
WriteLine("==============================================================================");
WriteLine("ParasingExpressionTreeByVisitor:");
WriteLine("{0}", ParasingExpressionTreeByVisitor.Parsing(lambda));
WriteLine("==============================================================================");
}
{
Expression <Func <int, int> > lambda = num => num + 100;
WriteLine("lambda :{0} ", ParsingExpressionTrees.ParsingExpression(lambda));
}
}
private void Test2()
{
var ParsingExpressionTrees = new ParsingExpressionTreeByVisitor();
ParameterExpression pExp = Expression.Parameter(typeof(String), "p"); //创建参数表达式 p
ConstantExpression aExp = Expression.Constant("A", typeof(String));
ConstantExpression bExp = Expression.Constant("B", typeof(String));
ConstantExpression cExp = Expression.Constant("C", typeof(String));
ConstantExpression dExp = Expression.Constant("D", typeof(String));
SwitchExpression switchExp = Expression.Switch(pExp
, Expression.Constant("未知")
, Expression.SwitchCase(Expression.Constant("aaaa", typeof(String)), aExp)
, Expression.SwitchCase(Expression.Constant("bbbb", typeof(String)), bExp)
, Expression.SwitchCase(Expression.Constant("cccc", typeof(String)), cExp)
, Expression.SwitchCase(Expression.Constant("dddd", typeof(String)), dExp)
);
LambdaExpression lambdaExp = Expression.Lambda(switchExp, pExp);
String strLambda = ParsingExpressionTrees.Parsing(switchExp);
WriteLine("{0}", strLambda);
}
public override void Test()
{
{
Expression< Func<String, bool>> where = p => (p.ToLower() == "coho winery" || p.Length > 16);
Expression<Func<String, int>> order = p => p.Length;
var Queryable = companies.Where(where.Compile()).OrderBy(order.Compile()).AsQueryable();
WriteLine("companies.Where(company => (p.ToLower() == \"coho winery\" || p.Length > 16)).OrderBy(p => p.Length).AsQueryable():");
foreach (var item in Queryable)
{
WriteLine(item);
}
WriteLine("============================ParsingExpressionTrees==========================");
WriteLine(parsing.ParsingExpression(where));
WriteLine(parsing.ParsingExpression(order));
WriteLine("======================================================");
WriteLine("============================ParsingExpressionTreeByVisitor==========================");
WriteLine(parsing2.Parsing(where));
WriteLine(parsing2.Parsing(order));
WriteLine("======================================================");
}
{
var queryableData = companies.AsQueryable();
var p1 = Expression.Parameter(typeof(IQueryable<String>), "queryableData");
var p = Expression.Parameter(typeof(string), "p");
var toLowerExp = Expression.Call(p, typeof(string).GetMethod("ToLower", new Type[0]));
var lengthExp = Expression.Property(p, "Length");
var exp1 = Expression.Equal(toLowerExp, Expression.Constant("coho winery",typeof(string)));
var exp2 = Expression.GreaterThan(lengthExp, Expression.Constant(16, typeof(int)));
var predicateBody = Expression.OrElse(exp1, exp2);
//创建一个表达式表示：'queryableData.Where(p => (p.ToLower() == "coho winery" || p.Length > 16))
MethodCallExpression whereCallExpression = Expression.Call(
typeof(Queryable),
"Where",
new Type[] { queryableData.ElementType },
queryableData.Expression,
Expression.Lambda<Func<string, bool>>(predicateBody, new ParameterExpression[] { p }));
MethodCallExpression orderByCallExpression = Expression.Call(
typeof(Queryable),
"OrderBy",
new Type[] { queryableData.ElementType, typeof(int) },
whereCallExpression,
Expression.Lambda<Func<String,int>>(lengthExp, new ParameterExpression[] { p }));
WriteLine("============================ParsingExpressionTrees==========================");
WriteLine(parsing.ParsingExpression(orderByCallExpression));
WriteLine("======================================================");
WriteLine("============================ParsingExpressionTreeByVisitor==========================");
WriteLine(parsing2.Parsing(orderByCallExpression));
WriteLine("======================================================");
var Queryable = queryableData.Provider.CreateQuery<string>(orderByCallExpression);
foreach (var item in Queryable)
{
WriteLine(item);
}
}
}