C#的λ表达式树(LambdaExpression)保姆级超详细简单入门教程
有看过我之前发表过的C#相关文章分享和阅读过我代码的朋友们可能会在我的代码里面经常看到各种各样的λ表达式动态拼接，C#的λ表达式树是一个好东西，也是别的语言学不来的，熟悉掌握λ表达式就能够实现各种linq场景的个性化操作，如动态拼接查询条件、排序方式等，也能够实现替代反射的高性能操作，比如我们常用到的IQueryable和IEnumerable，每个扩展方法就全是λ表达式树。
之前也分享过几篇关于λ表达式的文章，但鉴于还是有一部分初学者对于λ表达式树不太懂的，而网络上关于λ表达式树的科普不是很全面，今天就来填一下这个坑，分享一下λ表达式树的简单入门。
鉴于还有些伙伴不太清楚λ表达式树和委托的区别的，在教程正式开始之前，先科普下λ表达式树、lambda、委托它们之间的区别和联系吧。
λ表达式树、lambda、委托它们之间的区别和联系
1. 委托是一种类型，是方法的抽象，通过委托可以将方法以参数的形式传递给另一个方法，同时调用委托的时候，它缩包含的方法都会被实现。委托的关键字是delegate，可以自定义委托，也可以使用内置委托，通过简化，可以将Lambda表达式或Lambda语句赋值给委托，委托的调用包括同步调用和异步调用。
2. 表达式树(Expression)是一种数据结构，表达式树也称表达式目录树，是将代码以一种抽象的方式表示成一个对象树，树中每个节点本身都是一个表达式。表达式树不是可执行代码，它是一种数据结构。可以利用Lambda表达式进行声明，Lambda表达式的规则要符合Expression中Func委托的参数规则，但Lambda语句是不能声明的。
3. lambda是当委托只有一句话代码的时候的最简写形式。
4. Lambda表达式不仅可以用来创建委托实例，C#编译器也能够将他们转换成表达式树。
//Func委托,必须要有返回值，最后一个参数为返回值,前面为输入参数
Func func1 = new Func((int m, int n) =>
{
return m * n + 2;
});
//对其进行最简化(Lambda语句)
Func func2 = (m, n) =>
{
return m * n + 2;
};
//对其进行最简化(Lambda表达式)
Func func3 = (m, n) => m * n + 2;
//调用委托
int result1 = func1.Invoke(2, 3);
int result2 = func2.Invoke(2, 3);
int result3 = func3.Invoke(2, 3);
Console.WriteLine("委托三种形式结果分别为：{0},{1},{2}", result1, result2, result3);
λ表达式树入门
λ表达式树也是代码，我们把它当成另外一种动态语言学习就好了，它也有常量、参数、运算、判断等操作，λ表达式树最终的本质就是一个方法的编译状态，如：x=>x+1这个最基本的表达式，它对应的等效方法就是：
int Inc(int x){
return x+1;
}
我们分析x=>x+1表达式的每一个成分：
x：参数x；
=>：{}花括号；
+：add操作；
1：常量；
那为什么叫表达式树呢？
x=>x+1它的每一个成分都是一个节点，每个节点之间进行关联，得到最终的表达式，故称之为表达式树。如图所示：
再比如：(a,b)=>a*3+b*4，可视化结构如下：
通过Expression类构造一个最基本的λ表达式树
简单介绍之后，我们就开始实战吧，我们从最简单的开始，构造上面两个基本例子：
x=>x+1
var x=Expression.Parameter(typeof(int), "x");//声明一个int类型的参数x
var num1=Expression.Constant(1);//声明一个常量1
var inc=Expression.Add(x, num1); //执行加法操作
var lambda=Expression.Lambda>(inc,x);// 将表达式树组装成lambda表达式树，一个输入，一个输出，故Func
var func=lambda.Compile(); //将lambda表达式树编译成Func委托
一个最基本的表达式树编译完成，我们输出看一下长什么样子吧，并调用func(10)看看得到什么结果：
(a,b)=>a*3+b*4
看上去比上面的例子复杂了一点，但我们把它拆分成两个基本的表达式处理就好了，按照上面的图例，我们从下往上进行构建：
先组合a*3，再组合b*4，最后再将a*3和b*4进行两两组合即可完成。
var a = Expression.Parameter(typeof(int), "a");//声明一个int类型的参数a
var num1 = Expression.Constant(3);//声明一个常量3
var r1 = Expression.Multiply(a, num1);//乘法表达式，a*3
var b = Expression.Parameter(typeof(int), "b");//声明一个int类型的参数b
var num2 = Expression.Constant(4);//声明一个常量4
var r2 = Expression.Multiply(b, num2);//乘法表达式，b*4
var add = Expression.Add(r1, r2);//a*3+b*4
var lambda = Expression.Lambda>(add, a, b);// 将表达式树组装成lambda表达式树，两个输入，一个输出，故Func
var func = lambda.Compile(); //将lambda表达式树编译成Func委托
我们再来构造一个更复杂的表达式：
(a,b,c,d,e)=>((a+b)*(c-d))%e
有点蒙了吧，我们还是拆成最基本的两两组合就好了：
var a = Expression.Parameter(typeof(double), "a");
var b = Expression.Parameter(typeof(double), "b");
var r1 = Expression.Add(a, b);//a+b
var c = Expression.Parameter(typeof(double), "c");
var d = Expression.Parameter(typeof(double), "d");
var r2 = Expression.Subtract(c, d);//c-d
var r3 = Expression.Multiply(r1, r2);//(a+b)*(c-d)
var e = Expression.Parameter(typeof(double), "e");
var r4 = Expression.Modulo(r3, e);//(a+b)*(c-d)%e
var lambda = Expression.Lambda>(r4, a, b, c, d, e);
感觉这玩意儿有点意思了吧！接下来继续深入研究一些基本操作。
测试类
为方便接下来的示范，我们先新建一个class：
public class MyClass
{
public MyClass(int num)
{
Number = num;
}
public bool MyBool { get; set; }
public int Number { get; set; }
public string MyProperty { get; set; }
public List List { get; set; }
public string SayHello(string s)
{
return s + DateTime.Now.ToString("yyyy-MM-dd");
}
}
替代反射
创建实例new MyClass(100)
Expression.New操作可为class创建实例对象，比如我想通过λ表达式树实现var myClass = new MyClass(100); 其可视化结构如下：
代码实现：
var newExpression = Expression.New(typeof(MyClass).GetConstructor(new[] { typeof(int) }), Expression.Constant(100)); // 有参构造函数方式
//var newExpression = Expression.New(typeof(MyClass)); //无参构造函数方式
var lambda = Expression.Lambda>(newExpression);
var myClass = lambda.Compile()();
获取属性值e=>e.MyProperty
操作对象的属性我们需要用到Expression.Property，e=>e.MyProperty表达式分析得到两部分：参数和属性，也是一种基本表达式
Expression.Parameter可得到参数e；Expression.Property可得到属性MyProperty：
var e = Expression.Parameter(typeof(MyClass), "e");
var property = Expression.Property(e, nameof(MyClass.MyProperty));
var lambda = Expression.Lambda>(property, e);
为属性赋值e=>e.List=new List
结合上面的属性操作，既然能获取属性，那就一定能设置属性值，Expression.Assign操作便是赋值操作
var newExpression = Expression.New(typeof(MyClass).GetConstructor(new[] { typeof(int) }), Expression.Constant(100)); // 有参构造函数方式
var lambda = Expression.Lambda>(newExpression);
var myClass = lambda.Compile()();
var e = Expression.Parameter(typeof(MyClass), "e");
var property = Expression.Property(e, nameof(MyClass.MyProperty));
var assignString = Expression.Assign(property, Expression.Constant("sss"));//为字符串类型的属性赋值
var assignList = Expression.Assign(Expression.Property(e, "List"), Expression.Constant(new List() { "sdf" }));//为集合类型的属性赋值
Expression.Lambda>(assignList, e).Compile()(myClass);
Expression.Lambda>(assignString, e).Compile()(myClass);// 因为赋值操作没有返回值，所以是Action，并且只有一个入参
调用方法e=>e.GetHashCode();
调用方法通过Expression.Call进行对象的方法调用，调用前需要先获取被调用的方法对象
var e = Expression.Parameter(typeof(MyClass), "e");
var method = typeof(MyClass).GetMethod(nameof(GetHashCode));//获取MyClass的GetHashCode方法
var call = Expression.Call(e, method);//e.GetHashCode()
var lambda = Expression.Lambda>(call, e);
调用有参方法e=>e.SayHello("你好")
var e = Expression.Parameter(typeof(MyClass), "e");
var method = typeof(MyClass).GetMethod(nameof(MyClass.SayHello), new[] { typeof(string) });
var call = Expression.Call(e, method, Expression.Constant("你好"));//调用SayHello方法并给方法传入"你好"参数
var lambda = Expression.Lambda>(call, e);
调用Linq扩展方法e=>e.List.Contains("s")
首先我们要先获取到IEnumerable的Contains泛型扩展方法：
typeof(Enumerable).GetMethods().FirstOrDefault(info => info.GetParameters().Length == 2 && info.Name == "Contains").MakeGenericMethod(typeof(string))
其次扩展方法的调用需要通过一个null实例进行调用
Expression.Call(null, containsMethod, list, Expression.Constant("s"));
对于这样的链式调用，那λ表达式树的数据结构是什么样的呢？这种我们考虑从前往后构建就好了，翻译成树状结构如下：
所以完整代码如下：
var e = Expression.Parameter(typeof(MyClass), "e");
var list = Expression.Property(e, nameof(MyClass.List));//e.List
var containsMethod = typeof(Enumerable).GetMethods().FirstOrDefault(info => info.GetParameters().Length == 2 && info.Name == "Contains").MakeGenericMethod(typeof(string));
var contains = Expression.Call(null, containsMethod, list, Expression.Constant("s"));//e.List.Contains("s")
var lambda = Expression.Lambda>(contains, e);
以上对对象的基本操作完了，我们再来一点复杂的，调用Linq扩展方法
e=>e.List.Any(item=>item.Contains("s"))
这看上去有点懵，表达式嵌套表达式，我们结合之前的方法调用和扩展方法调用，打一套组合拳就好了，表达式它也是一种参数类型嘛，我们先从里往外，再从前往后，λ表达式树的数据结构如下，先上图再写代码就不再懵：
所以，代码如下：
var e = Expression.Parameter(typeof(MyClass), "e");
var s = Expression.Parameter(typeof(string), "s");
var anyContains = Expression.Call(s, typeof(string).GetMethod("Contains", new[] { typeof(string) }), Expression.Constant("a"));// s.Contains("a")
var containsLambda = Expression.Lambda(anyContains, s);//s=>s.Contains("a")
var any = typeof(Enumerable).GetMethods().FirstOrDefault(info => info.GetParameters().Length == 2 && info.Name == "Any").MakeGenericMethod(typeof(string));
var list = Expression.Property(e, nameof(MyClass.List));//e.List
var whereLambda = Expression.Call(null, any, list, containsLambda); // e.List.Any(s=>s.Contains("a")
var lambda = Expression.Lambda>(whereLambda, e);
对象的玩法暂时就只想到了这么多，以后想到了别的案例再随时补充。
三目表达式x=>x>60?"及格":"不及格"
这个表达式需要用到Expression.Condition，即可生成三目表达式的λ表达式树。其数据结构如下图：
代码实现如下：
var x = Expression.Parameter(typeof(int), "x");
var gt60 = Expression.GreaterThan(x, Expression.Constant(60));//x>60
var condition = Expression.Condition(gt60, Expression.Constant("及格"), Expression.Constant("不及格"));//x>60?"及格":"不及格"
var lambda = Expression.Lambda>(condition, x);//x=>x>60?"及格":"不及格"
很简单是吧，那就又来个组合拳吧。
e => e.MyBool ? "真的" : "假的";
三目运算符+成员访问，还好，不算有难度。
var e = Expression.Parameter(typeof(MyClass), "e");
var expression = Expression.Property(e, "MyBool");
var condition = Expression.Condition(expression, Expression.Constant("真的"), Expression.Constant("假的"));
var lambda = Expression.Lambda>(condition, e);
null值表达式e=>e.MyProperty??"s"
Expression.Coalesce便是对标的C#6专属的null值表达式
var e = Expression.Parameter(typeof(MyClass), "e");
var expression = Expression.Property(e, "MyProperty");
var coalesce = Expression.Coalesce(expression, Expression.Constant("s"));
var lambda = Expression.Lambda>(coalesce, e);
类型转换Convert.ToInt32(x)
Expression.Convert即等价于Convert静态类，如通过Expression.Convert替代Convert.ToInt32：
var convert = Expression.Convert(Expression.Constant(10.234), typeof(int));
var lambda = Expression.Lambda>(convert);
声明一个数组对象
Expression.NewArrayBounds即可生成一个创建数组对象的表达式：
var array = Expression.NewArrayBounds(typeof(string), Expression.Constant(5));
var lambda = Expression.Lambda>(array);
现在有了这么多的基础储备，那么接下来就来点复杂的实战吧！
实现条件表达式m=>m.MyProperty.Contains("ldqk")||m.List.Any(s=>s.Length>1&&s.Contains("a"))
我们还是先画出流程图，写代码不乱
写代码也没有必要按照刚才说的从内到外从前往后的顺序，也可以按局部到全部的方式来。我们一步一步便得到下面的代码：
var s = Expression.Parameter(typeof(string), "s");
var length = Expression.Property(s, "Length"); // s.Length
var gt10 = Expression.GreaterThan(length, Expression.Constant(1));// s.Length>1
var anyContains = Expression.Call(s, typeof(string).GetMethod("Contains", new[] { typeof(string) }), Expression.Constant("a"));// s.Contains("a")
var anyWhere = Expression.AndAlso(gt10, anyContains); // s.Length>1&&s.Contains("a")
var anyLambda = Expression.Lambda(anyWhere, s);// s=>s.Length>1&&s.Contains("a")
var any = typeof(Enumerable).GetMethods().FirstOrDefault(info => info.GetParameters().Length == 2 && info.Name == "Any").MakeGenericMethod(typeof(string));
var m = Expression.Parameter(typeof(MyClass), "m");
var prop = Expression.Property(m, "List");// List.Any(s=>s.Length>1&&s.Contains("a")
var whereLambda = Expression.Call(null, any, prop, anyLambda); // m.List.Any(s=>s.Length>1&&s.Contains("a")
var property = Expression.Property(m, nameof(MyClass.MyProperty));// m.MyProperty
var contains = Expression.Call(property, typeof(string).GetMethod("Contains", new[] { typeof(string) }), Expression.Constant("ldqk"));// m.MyProperty.Contains("ldqk")
var lambda = Expression.Lambda>(Expression.OrElse(contains, whereLambda), m); // m=>m.MyProperty.Contains("ldqk")||m.List.Any(s=>s.Length>1&&s.Contains("a"))
链式调用s=>s.List.Select(e => e.Length).OrderBy(x=>x).FirstOrDefault() > 1
这就比上面的这个例子简单多了，直接从左往右一步一步实现就好了
var s = Expression.Parameter(typeof(MyClass), "s");
var prop = Expression.Property(s, "List"); // s.List
var selectMethod = typeof(Enumerable).GetMethods().FirstOrDefault(info => info.GetParameters().Length == 2 && info.Name == "Select").MakeGenericMethod(typeof(string), typeof(int));
var e = Expression.Parameter(typeof(string), "e");
var selectlength = Expression.Property(e, "Length"); // e.Length
var selectLambda = Expression.Lambda(selectlength, e); // e => e.Length
var select = Expression.Call(null, selectMethod, prop, selectLambda); //s.List.Select(e => e.Length)
var orderby = typeof(Enumerable).GetMethods().FirstOrDefault(info => info.GetParameters().Length == 2 && info.Name == "OrderBy").MakeGenericMethod(typeof(int), typeof(int));
var parameter = Expression.Parameter(typeof(int), "x");
var orderbyLambda = Expression.Lambda(parameter, parameter); //x=>x
var orderbyCall = Expression.Call(null, @orderby, @select, orderbyLambda); //s.List.Select(e => e.Length).OrderBy(x=>x)
var first = typeof(Enumerable).GetMethods().FirstOrDefault(info => info.GetParameters().Length == 1 && info.Name == "FirstOrDefault").MakeGenericMethod(typeof(int));
var firstExp = Expression.Call(null, first, orderbyCall); //s.List.Select(e => e.Length).OrderBy(x=>x).FirstOrDefault()
var greaterThan = Expression.GreaterThan(firstExp, Expression.Constant(1)); //s.List.Select(e => e.Length).OrderBy(x=>x).FirstOrDefault() > 1
var lambda = Expression.Lambda>(greaterThan, s); //s.List.Select(e => e.Length).OrderBy(x=>x).FirstOrDefault() >= 1
λ表达式树的高级用法
λ表达式树可以结合 数据库查询 或 Linq，衍生很多高级操作。例如 动态查询、遍历表达式树、转成成 SQL where 子句等等，这里给大家提供微软官方给出的全部操作符、表达式和方法，供大家深入学习和参考。
一、Expression中的操作运算符
| 成员名称 | 说明 |
|---|---|
| Add | 加法运算，如 a + b, ，不进行溢出检查，针对数值操作数。 |
| AddAssign | 加法复合赋值运算，如 (a += b), ，不进行溢出检查，针对数值操作数。 |
| AddAssignChecked | 加法复合赋值运算，如 (a += b), ，进行溢出检查，针对数值操作数。 |
| AddChecked | 加法运算，如 (a + b), ，进行溢出检查，针对数值操作数。 |
| And | 按位或逻辑 AND 操作，如 (a & b) 在 C# 和 (a And b) 在 Visual Basic 中。 |
| AndAlso | 在条件 AND 仅当第一个操作数的计算结果为才计算第二个操作数的操作 true。 它对应于 (a && b) 在 C# 和 (a AndAlso b) 在 Visual Basic 中。 |
| AndAssign | 按位或逻辑 AND 复合赋值运算，如 (a &= b) C# 中。 |
| ArrayIndex | 索引操作在一维数组中，如 array[index] 在 C# 或 array(index) 在 Visual Basic 中。 |
| ArrayLength | 获取一维数组的长度，如操作 array.Length。 |
| Assign | 赋值运算，如 (a = b)。 |
| Block | 表达式的块。 |
| Call | 某个方法调用，如在 obj.sampleMethod() 表达式。 |
| Coalesce | 一个表示空合并操作，如节点 (a ?? b) 在 C# 或 If(a, b) 在 Visual Basic 中。 |
| Conditional | 条件运算，如 a > b ? a : b 在 C# 或 If(a > b, a, b) 在 Visual Basic 中。 |
| Constant | 常量的值。 |
| Convert | 强制转换或转换操作中，如 (SampleType)obj C# 中或 CType(obj, SampleType) 在 Visual Basic 中。 对于数值的转换，如果转换后的值对于目标类型来说太大不引发异常。 |
| ConvertChecked | 强制转换或转换操作中，如 (SampleType)obj C# 中或 CType(obj, SampleType) 在 Visual Basic 中。 对于数值的转换，如果转换后的值不符合目标类型是引发异常。 |
| DebugInfo | 调试信息。 |
| Decrement | 一元递减操作，如 (a - 1) C# 和 Visual Basic 中。 该对象 a 不应就地修改。 |
| Default | 默认值。 |
| Divide | 除法运算，如 (a / b), ，针对数值操作数。 |
| DivideAssign | 除的复合赋值运算，如 (a /= b), ，针对数值操作数。 |
| Dynamic | 动态操作。 |
| Equal | 一个表示相等比较，如节点 (a == b) 在 C# 或 (a = b) 在 Visual Basic 中。 |
| ExclusiveOr | 按位或逻辑 XOR 操作，如 (a ^ b) 在 C# 或 (a Xor b) 在 Visual Basic 中。 |
| ExclusiveOrAssign | 按位或逻辑 XOR 复合赋值运算，如 (a ^= b) C# 中。 |
| Extension | 扩展表达式。 |
| Goto | 一个"转到"表达式，如 goto Label 在 C# 或 GoTo Label 在 Visual Basic 中。 |
| GreaterThan | "大于"比较，如 (a > b)。 |
| GreaterThanOrEqual | "大于或等于"比较，如 (a >= b)。 |
| Increment | 一元递增操作，如 (a + 1) C# 和 Visual Basic 中。 该对象 a 不应就地修改。 |
| Index | 索引操作或访问不采用参数的属性的操作。 |
| Invoke | 操作调用的委托或 lambda 表达式，如 sampleDelegate.Invoke()。 |
| IsFalse | 一个 false 条件值。 |
| IsTrue | 一个 true 条件值。 |
| Label | 标签。 |
| Lambda | Lambda 表达式，如 a => a + a 在 C# 或 Function(a) a + a 在 Visual Basic 中。 |
| LeftShift | 按位左移运算，如 (a << b)。 |
| LeftShiftAssign | 按位左移复合赋值运算，如 (a <<= b)。 |
| LessThan | "小于"比较，如 (a < b)。 |
| LessThanOrEqual | "小于或等于"比较，如 (a <= b)。 |
| ListInit | 创建一个新的操作的 IEnumerable 对象，并对其进行初始化从列表中的元素，如 new List |
| Loop | 一个循环，如 for 或 while。 |
| MemberAccess | 从一个字段或属性，如读取操作 obj.SampleProperty。 |
| MemberInit | 运算，创建一个新的对象并初始化一个或多个成员，如 new Point { X = 1, Y = 2 } 在 C# 或 New Point With {.X = 1, .Y = 2} 在 Visual Basic 中。 |
| Modulo | 算术余数运算，如 (a % b) 在 C# 或 (a Mod b) 在 Visual Basic 中。 |
| ModuloAssign | 算术余数复合赋值运算，如 (a %= b) C# 中。 |
| Multiply | 乘法运算，如 (a * b), ，不进行溢出检查，针对数值操作数。 |
| MultiplyAssign | 乘法复合赋值运算，如 (a *= b), ，不进行溢出检查，针对数值操作数。 |
| MultiplyAssignChecked | 乘法复合赋值运算，如 (a *= b), ，，进行溢出检查，针对数值操作数。 |
| MultiplyChecked | 乘法运算，如 (a * b), ，，进行溢出检查，针对数值操作数。 |
| Negate | 算术求反运算，如 (-a)。 该对象 a 不应就地修改。 |
| NegateChecked | 算术求反运算，如 (-a), ，，进行溢出检查。 该对象 a 不应就地修改。 |
| New | 调用构造函数以创建新的对象，如操作 new SampleType()。 |
| NewArrayBounds | 创建一个新数组，其中每个维度的下限指定，如操作 new SampleType[dim1, dim2] 在 C# 或 New SampleType(dim1, dim2) 在 Visual Basic 中。 |
| NewArrayInit | 操作，创建一个新的一维数组并对其进行初始化从列表中的元素，如 new SampleType[]{a, b, c} 在 C# 或New SampleType(){a, b, c} 在 Visual Basic 中。 |
| Not | 按位求补或逻辑求反运算。 在 C# 中，则等同于 (~a) 整型和 (!a) 布尔值。 在 Visual Basic 中，则等同于 (Not a)。 该对象 a 不应就地修改。 |
| NotEqual | 不相等比较，如 (a != b) 在 C# 或 (a <> b) 在 Visual Basic 中。 |
| OnesComplement | 一个二进制反码运算，如 (~a) C# 中。 |
| Or | 按位或逻辑 OR 操作，如 (a | b) 在 C# 或 (a Or b) 在 Visual Basic 中。 |
| OrAssign | 按位或逻辑 OR 复合赋值运算，如 (a |= b) C# 中。 |
| OrElse | 短路条件 OR 操作，如 (a || b) 在 C# 或 (a OrElse b) 在 Visual Basic 中。 |
| Parameter | 对参数或变量的表达式的上下文中定义的引用。 有关更多信息，请参见ParameterExpression。 |
| PostDecrementAssign | 一元后缀递减，如 (a--)。 该对象 a 应就地修改。 |
| PostIncrementAssign | 一元后缀递增，如 (a++)。 该对象 a 应就地修改。 |
| Power | 如引发数字进行幂运算的数学运算 (a ^ b) 在 Visual Basic 中。 |
| PowerAssign | 如引发数字进行幂运算的复合赋值运算 (a ^= b) 在 Visual Basic 中。 |
| PreDecrementAssign | 一元前缀递减，如 (--a)。 该对象 a 应就地修改。 |
| PreIncrementAssign | 一元前缀递增，如 (++a)。 该对象 a 应就地修改。 |
| Quote | 具有类型的常量值的表达式 Expression。 一个 Quote 节点可以包含对它所代表的表达式的上下文中定义的参数的引用。 |
| RightShift | 按位右移运算，如 (a >> b)。 |
| RightShiftAssign | 按位右移复合赋值运算，如 (a >>= b)。 |
| RuntimeVariables | 运行时变量的列表。 有关详细信息，请参阅RuntimeVariablesExpression。 |
| Subtract | 减法运算，如 (a - b), ，不进行溢出检查，针对数值操作数。 |
| SubtractAssign | 减法复合赋值运算，如 (a -= b), ，不进行溢出检查，针对数值操作数。 |
| SubtractAssignChecked | 减法复合赋值运算，如 (a -= b), ，，进行溢出检查，针对数值操作数。 |
| SubtractChecked | 算术减法运算，如 (a - b), ，，进行溢出检查，针对数值操作数。 |
| Switch | 一个切换操作，如 switch 在 C# 或 Select Case 在 Visual Basic 中。 |
| Throw | 引发异常，如操作 throw new Exception()。 |
| Try | 一个 try-catch 表达式。 |
| TypeAs | 显式引用或装箱转换在其中 null 如果转换失败，如提供 (obj as SampleType) 在 C# 或 TryCast(obj, SampleType) 在 Visual Basic 中。 |
| TypeEqual | 确切类型测试。 |
| TypeIs | 一种类型测试，如 obj is SampleType 在 C# 或 TypeOf obj is SampleType 在 Visual Basic 中。 |
| UnaryPlus | 一元正运算，如 (+a)。 预定义的一元正运算的结果是操作数的值，但用户定义的实现可能有不寻常的结果。 |
| Unbox | 取消装箱值类型的操作，如 unbox 和 unbox.any MSIL 中的说明。 |
二、Expression分类与操作运算符
| Expression | 操作说明 |
|---|---|
| BinaryExpression | 表示具有二进制运算符的表达式 |
| UnaryExpression | 表示具有一元运算符的表达式 |
| BlockExpression | 表示包含一个表达式序列的块，表达式中可定义变量 |
| ConditionalExpression | 表示具有条件运算符的表达式 |
| ConstantExpression | 表示具有常数值的表达式 |
| DefaultExpression | 表示一个类型或空表达式的默认值 |
| DynamicExpression | 表示一个动态操作 |
| GotoExpression | 表示无条件跳转。 这包括返回语句，break 和 continue 语句以及其他跳转。 |
| IndexExpression | 表示对一个属性或数组进行索引 |
| InvocationExpression | 表示一个将委托或 lambda 表达式应用到一个自变量表达式列表的表达式 |
| LabelExpression | 表示一个标签，可以放置在任何 Expression 上下文。 如果它跳转到，它会提供相应的值 GotoExpression。 否则，它接收中的值 DefaultValue。 如果 Type 等于 System.Void，则应提供任何值 |
| LambdaExpression | 介绍 lambda 表达式。 它捕获一个类似于 .NET 方法主体的代码块 |
| ListInitExpression | 表示具有集合初始值设定项的构造函数调用 |
| LoopExpression | 表示无限循环。 可通过“中断”退出该循环 |
| MemberExpression | 表示访问字段或属性 |
| MemberInitExpression | 表示调用构造函数并初始化新对象的一个或多个成员 |
| MethodCallExpression | 表示对静态方法或实例方法的调用 |
| NewArrayExpression | 表示创建一个新数组，并可能初始化该新数组的元素 |
| NewExpression | 表示一个构造函数调用 |
| ParameterExpression | 表示一个命名的参数表达式 |
| SwitchExpression | 表示通过将控制权传递给处理多个选择的控件表达式 SwitchCase |
| TryExpression | 表示一个 try/catch/finally/fault 块 |
| TypeBinaryExpression | 表示表达式和类型之间的操作 |
三、Expression的操作方法
| 名称 | 说明 |
|---|---|
| Accept(ExpressionVisitor) | 调度到此节点类型的特定 Visit 方法。 例如，MethodCallExpression 调用 VisitMethodCall。 |
| Add(Expression, Expression) | 创建一个表示不进行溢出检查的算术加法运算的 BinaryExpression。 |
| Add(Expression, Expression, MethodInfo) | 创建一个表示不进行溢出检查的算术加法运算的 BinaryExpression。 可指定实现方法。 |
| AddAssign(Expression, Expression) | 创建一个表示不进行溢出检查的加法赋值运算的 BinaryExpression。 |
| AddAssign(Expression, Expression, MethodInfo) | 创建一个表示不进行溢出检查的加法赋值运算的 BinaryExpression。 |
| AddAssign(Expression, Expression, MethodInfo, LambdaExpression) | 创建一个表示不进行溢出检查的加法赋值运算的 BinaryExpression。 |
| AddAssignChecked(Expression, Expression) | 创建一个表示进行溢出检查的加法赋值运算的 BinaryExpression。 |
| AddAssignChecked(Expression, Expression, MethodInfo) | 创建一个表示进行溢出检查的加法赋值运算的 BinaryExpression。 |
| AddAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) | 创建一个表示进行溢出检查的加法赋值运算的 BinaryExpression。 |
| AddChecked(Expression, Expression) | 创建一个表示进行溢出检查的算术加法运算的 BinaryExpression。 |
| AddChecked(Expression, Expression, MethodInfo) | 创建一个表示进行溢出检查的算术加法运算的 BinaryExpression。 可指定实现方法。 |
| And(Expression, Expression) | 创建一个表示按位 BinaryExpression 运算的 AND。 |
| And(Expression, Expression, MethodInfo) | 创建一个表示按位 BinaryExpression 运算的 AND。 可指定实现方法。 |
| AndAlso(Expression, Expression) | 创建一个 BinaryExpression，它表示仅在第一个操作数的计算结果为 AND 时才计算第二个操作数的条件 true 运算。 |
| AndAlso(Expression, Expression, MethodInfo) | 创建一个 BinaryExpression，它表示仅在第一个操作数解析为 true 时，才计算第二个操作数的条件 AND 运算。 可指定实现方法。 |
| AndAssign(Expression, Expression) | 创建一个表示按位 AND 赋值运算的 BinaryExpression。 |
| AndAssign(Expression, Expression, MethodInfo) | 创建一个表示按位 AND 赋值运算的 BinaryExpression。 |
| AndAssign(Expression, Expression, MethodInfo, LambdaExpression) | 创建一个表示按位 AND 赋值运算的 BinaryExpression。 |
| ArrayAccess(Expression, Expression[]) | 创建一个用于访问数组的 IndexExpression。 |
| ArrayAccess(Expression, IEnumerable |
创建一个用于访问多维数组的 IndexExpression。 |
| ArrayIndex(Expression, Expression) | 创建一个 BinaryExpression，它表示将数组索引运算符应用到级别一的数组中。 |
| ArrayIndex(Expression, Expression[]) | 创建一个 MethodCallExpression，它表示将数组索引运算符应用到多维数组中。 |
| ArrayIndex(Expression, IEnumerable |
创建一个 MethodCallExpression，它表示将数组索引运算符应用到多个级别的数组中。 |
| ArrayLength(Expression) | 创建一个 UnaryExpression，它表示获取一维数组的长度的表达式。 |
| Assign(Expression, Expression) | 创建一个表示赋值运算的 BinaryExpression。 |
| Bind(MemberInfo, Expression) | 创建一个 MemberAssignment，它表示字段或属性的初始化。 |
| Bind(MethodInfo, Expression) | 使用属性访问器方法，创建一个表示成员初始化的 MemberAssignment。 |
| Block(Expression, Expression) | 创建一个 BlockExpression，其中包含两个表达式，但不包含任何变量。 |
| Block(Expression, Expression, Expression) | 创建一个 BlockExpression，其中包含三个表达式，但不包含任何变量。 |
| Block(Expression, Expression, Expression, Expression) | 创建一个 BlockExpression，其中包含四个表达式，但不包含任何变量。 |
| Block(Expression, Expression, Expression, Expression, Expression) | 创建一个 BlockExpression，其中包含五个表达式，但不包含任何变量。 |
| Block(Expression[]) | 创建一个 BlockExpression，其中包含给定表达式，但不包含任何变量。 |
| Block(IEnumerable |
创建一个 BlockExpression，其中包含给定表达式，但不包含任何变量。 |
| Block(IEnumerable |
创建一个 BlockExpression，其中包含给定的变量和表达式。 |
| Block(IEnumerable |
创建一个 BlockExpression，其中包含给定的变量和表达式。 |
| Block(Type, Expression[]) | 创建一个 BlockExpression，其中包含给定表达式和特定结果类型，但不包含任何变量。 |
| Block(Type, IEnumerable |
创建一个 BlockExpression，其中包含给定表达式和特定结果类型，但不包含任何变量。 |
| Block(Type, IEnumerable |
创建一个 BlockExpression，其中包含给定的变量和表达式。 |
| Block(Type, IEnumerable |
创建一个 BlockExpression，其中包含给定的变量和表达式。 |
| Break(LabelTarget) | 创建一个表示 break 语句的 GotoExpression。 |
| Break(LabelTarget, Expression) | 创建一个表示 break 语句的 GotoExpression。 可以指定在跳转时传递给标签的值。 |
| Break(LabelTarget, Expression, Type) | 创建一个表示具有指定类型的 break 语句的 GotoExpression。 可以指定在跳转时传递给标签的值。 |
| Break(LabelTarget, Type) | 创建一个表示具有指定类型的 break 语句的 GotoExpression。 |
| Call(Expression, MethodInfo) | 创建一个 MethodCallExpression，它表示调用不带参数的方法。 |
| Call(Expression, MethodInfo, Expression, Expression) | 创建一个 MethodCallExpression，它表示对采用两个参数的方法的调用。 |
| Call(Expression, MethodInfo, Expression, Expression, Expression) | 创建一个 MethodCallExpression，它表示对使用三个参数的方法的调用。 |
| Call(Expression, MethodInfo, Expression[]) | 创建一个表示调用带参数的方法的 MethodCallExpression。 |
| Call(Expression, MethodInfo, IEnumerable |
创建一个表示调用带参数的方法的 MethodCallExpression。 |
| Call(Expression, String, Type[], Expression[]) | 通过调用合适的工厂方法，创建一个 MethodCallExpression，它表示方法调用。 |
| Call(MethodInfo, Expression) | 创建一个 MethodCallExpression，它表示对使用一个参数的 static 方法（在 Visual Basic 中为 Shared 方法）的调用。 |
| Call(MethodInfo, Expression, Expression) | 创建一个 MethodCallExpression，它表示对使用两个参数的静态方法的调用。 |
| Call(MethodInfo, Expression, Expression, Expression) | 创建一个 MethodCallExpression，它表示对使用三个参数的静态方法的调用。 |
| Call(MethodInfo, Expression, Expression, Expression, Expression) | 创建一个 MethodCallExpression，它表示对使用四个参数的静态方法的调用。 |
| Call(MethodInfo, Expression, Expression, Expression, Expression, Expression) | 创建一个 MethodCallExpression，它表示对使用五个参数的静态方法的调用。 |
| Call(MethodInfo, Expression[]) | 创建一个 MethodCallExpression，它表示调用有参数的 static（在 Visual Basic 中为 Shared）方法。 |
| Call(MethodInfo, IEnumerable |
创建一个 MethodCallExpression，它表示对 static 方法（在 Visual Basic 中为 Shared 方法）的调用。 |
| Call(Type, String, Type[], Expression[]) | 通过调用合适的工厂方法，创建一个 MethodCallExpression，它表示对 static（在 Visual Basic 中为 Shared）方法的调用。 |
| Catch(ParameterExpression, Expression) | 创建一个表示 catch 语句的 CatchBlock，其中具有对已捕获的 Exception 对象的引用以便在处理程序主体中使用。 |
| Catch(ParameterExpression, Expression, Expression) | 创建一个表示 catch 语句的 CatchBlock，其中具有 Exception 筛选器和对已捕获的 Exception 对象的引用。 |
| Catch(Type, Expression) | 创建一个表示 catch 语句的 CatchBlock。 |
| Catch(Type, Expression, Expression) | 创建一个表示 catch 语句的 CatchBlock，其中具有 Exception 筛选器，但没有对已捕获的 Exception 对象的引用。 |
| ClearDebugInfo(SymbolDocumentInfo) | 创建一个用于清除序列点的 DebugInfoExpression。 |
| Coalesce(Expression, Expression) | 创建一个表示合并运算的 BinaryExpression。 |
| Coalesce(Expression, Expression, LambdaExpression) | 在给定转换函数的情况下，创建一个表示合并运算的 BinaryExpression。 |
| Condition(Expression, Expression, Expression) | 创建一个表示条件语句的 ConditionalExpression。 |
| Condition(Expression, Expression, Expression, Type) | 创建一个表示条件语句的 ConditionalExpression。 |
| Constant(Object) | 创建一个 ConstantExpression，它把 Value 属性设置为指定值。 |
| Constant(Object, Type) | 创建一个 ConstantExpression，它把 Value 和 Type 属性设置为指定值。 |
| Continue(LabelTarget) | 创建一个表示 continue 语句的 GotoExpression。 |
| Continue(LabelTarget, Type) | 创建一个表示具有指定类型的 continue 语句的 GotoExpression。 |
| Convert(Expression, Type) | 创建一个表示类型转换运算的 UnaryExpression。 |
| Convert(Expression, Type, MethodInfo) | 创建一个 UnaryExpression，它表示为其指定实现方法的转换运算。 |
| ConvertChecked(Expression, Type) | 创建一个 UnaryExpression，它表示在目标类型发生溢出时引发异常的转换运算。 |
| ConvertChecked(Expression, Type, MethodInfo) | 创建一个 UnaryExpression，它表示在目标类型发生溢出时引发异常且为其指定实现方法的转换运算。 |
| DebugInfo(SymbolDocumentInfo, Int32, Int32, Int32, Int32) | 创建一个具有指定跨度的 DebugInfoExpression。 |
| Decrement(Expression) | 创建一个 UnaryExpression，它表示按 1 递减表达式值。 |
| Decrement(Expression, MethodInfo) | 创建一个 UnaryExpression，它表示按 1 递减表达式值。 |
| Default(Type) | 创建一个 DefaultExpression，Type 属性设置为指定类型。 |
| Divide(Expression, Expression) | 创建一个表示算术除法运算的 BinaryExpression。 |
| Divide(Expression, Expression, MethodInfo) | 创建一个表示算术除法运算的 BinaryExpression。 可指定实现方法。 |
| DivideAssign(Expression, Expression) | 创建一个表示不进行溢出检查的除法赋值运算的 BinaryExpression。 |
| DivideAssign(Expression, Expression, MethodInfo) | 创建一个表示不进行溢出检查的除法赋值运算的 BinaryExpression。 |
| DivideAssign(Expression, Expression, MethodInfo, LambdaExpression) | 创建一个表示不进行溢出检查的除法赋值运算的 BinaryExpression。 |
| Dynamic(CallSiteBinder, Type, Expression) | 创建一个 DynamicExpression，它表示由提供的 CallSiteBinder 绑定的动态操作。 |
| Dynamic(CallSiteBinder, Type, Expression, Expression) | 创建一个 DynamicExpression，它表示由提供的 CallSiteBinder 绑定的动态操作。 |
| Dynamic(CallSiteBinder, Type, Expression, Expression, Expression) | 创建一个 DynamicExpression，它表示由提供的 CallSiteBinder 绑定的动态操作。 |
| Dynamic(CallSiteBinder, Type, Expression, Expression, Expression, Expression) | 创建一个 DynamicExpression，它表示由提供的 CallSiteBinder 绑定的动态操作。 |
| Dynamic(CallSiteBinder, Type, Expression[]) | 创建一个 DynamicExpression，它表示由提供的 CallSiteBinder 绑定的动态操作。 |
| Dynamic(CallSiteBinder, Type, IEnumerable |
创建一个 DynamicExpression，它表示由提供的 CallSiteBinder 绑定的动态操作。 |
| ElementInit(MethodInfo, Expression[]) | 在给定值数组作为第二个参数的情况下，创建一个 ElementInit。 |
| ElementInit(MethodInfo, IEnumerable |
在给定 ElementInit 作为第二个参数的情况下，创建一个 IEnumerable |
| Empty() | 创建具有 Void 类型的空表达式。 |
| Equal(Expression, Expression) | 创建一个表示相等比较的 BinaryExpression。 |
| Equal(Expression, Expression, Boolean, MethodInfo) | 创建一个表示相等比较的 BinaryExpression。 可指定实现方法。 |
| Equals(Object) | 确定指定的对象是否等于当前对象。（继承自 Object。） |
| ExclusiveOr(Expression, Expression) | 通过对用户定义的类型使用 BinaryExpression，创建一个表示按位 XOR 运算的 op_ExclusiveOr。 |
| ExclusiveOr(Expression, Expression, MethodInfo) | 通过对用户定义的类型使用 BinaryExpression，创建一个表示按位 XOR 运算的 op_ExclusiveOr。 可指定实现方法。 |
| ExclusiveOrAssign(Expression, Expression) | 通过对用户定义的类型使用 BinaryExpression，创建一个表示按位 XOR 赋值运算的 op_ExclusiveOr。 |
| ExclusiveOrAssign(Expression, Expression, MethodInfo) | 通过对用户定义的类型使用 BinaryExpression，创建一个表示按位 XOR 赋值运算的 op_ExclusiveOr。 |
| ExclusiveOrAssign(Expression, Expression, MethodInfo, LambdaExpression) | 通过对用户定义的类型使用 BinaryExpression，创建一个表示按位 XOR 赋值运算的 op_ExclusiveOr。 |
| Field(Expression, FieldInfo) | 创建一个表示访问字段的 MemberExpression。 |
| Field(Expression, String) | 在给定字段名称的情况下，创建一个表示访问此字段的 MemberExpression。 |
| Field(Expression, Type, String) | 创建一个表示访问字段的 MemberExpression。 |
| Finalize() | 在垃圾回收将某一对象回收前允许该对象尝试释放资源并执行其他清理操作。（继承自 Object。） |
| GetActionType(Type[]) | 创建一个 Type 对象，它表示具有特定类型参数的泛型 System.Action 委托类型。 |
| GetDelegateType(Type[]) | 获取一个 Type 对象，它表示具有特定类型参数的泛型 System.Func 或 System.Action 委托类型。 |
| GetFuncType(Type[]) | 创建一个 Type 对象，它表示具有特定类型参数的泛型 System.Func 委托类型。 最后一个类型参数指定已创建委托的返回类型。 |
| GetHashCode() | 作为默认哈希函数。（继承自 Object。） |
| GetType() | 获取当前实例的 Type。（继承自 Object。） |
| Goto(LabelTarget) | 创建一个表示“go to”语句的 GotoExpression。 |
| Goto(LabelTarget, Expression) | 创建一个表示“go to”语句的 GotoExpression。 可以指定在跳转时传递给标签的值。 |
| Goto(LabelTarget, Expression, Type) | 创建一个表示具有指定类型的“go to”语句的 GotoExpression。 可以指定在跳转时传递给标签的值。 |
| Goto(LabelTarget, Type) | 创建一个表示具有指定类型的“go to”语句的 GotoExpression。 |
| GreaterThan(Expression, Expression) | 创建一个表示“大于”数值比较的 BinaryExpression。 |
| GreaterThan(Expression, Expression, Boolean, MethodInfo) | 创建一个表示“大于”数值比较的 BinaryExpression。 可指定实现方法。 |
| GreaterThanOrEqual(Expression, Expression) | 创建一个表示“大于或等于”数值比较的 BinaryExpression。 |
| GreaterThanOrEqual(Expression, Expression, Boolean, MethodInfo) | 创建一个表示“大于或等于”数值比较的 BinaryExpression。 |
| IfThen(Expression, Expression) | 创建一个 ConditionalExpression，它表示带 if 语句的条件块。 |
| IfThenElse(Expression, Expression, Expression) | 创建一个 ConditionalExpression，它表示带 if 和 else 语句的条件块。 |
| Increment(Expression) | 创建一个 UnaryExpression，它表示按 1 递增表达式值。 |
| Increment(Expression, MethodInfo) | 创建一个 UnaryExpression，它表示按 1 递增表达式值。 |
| Invoke(Expression, Expression[]) | 创建一个 InvocationExpression，它将委托或 lambda 表达式应用于一个参数表达式列表。 |
| Invoke(Expression, IEnumerable |
创建一个 InvocationExpression，它将委托或 lambda 表达式应用于一个参数表达式列表。 |
| IsFalse(Expression) | 返回表达式的计算结果是否为 false。 |
| IsFalse(Expression, MethodInfo) | 返回表达式的计算结果是否为 false。 |
| IsTrue(Expression) | 返回表达式的计算结果是否为 true。 |
| IsTrue(Expression, MethodInfo) | 返回表达式的计算结果是否为 true。 |
| Label() | 创建一个 LabelTarget，它表示具有 void 类型但没有名称的标签。 |
| Label(LabelTarget) | 创建一个LabelExpression，它表示不带默认值的标签。 |
| Label(LabelTarget, Expression) | 创建一个 LabelExpression，它表示具有给定默认值的标签。 |
| Label(String) | 创建一个 LabelTarget，它表示具有 void 类型和给定名称的标签。 |
| Label(Type) | 创建一个 LabelTarget，它表示具有给定类型的标签。 |
| Label(Type, String) | 创建一个 LabelTarget，它表示具有给定类型和名称的标签。 |
| Lambda(Expression, Boolean, IEnumerable |
通过先构造一个委托类型来创建一个 LambdaExpression。 |
| Lambda(Expression, Boolean, ParameterExpression[]) | 通过先构造一个委托类型来创建一个 LambdaExpression。 |
| Lambda(Expression, IEnumerable |
通过先构造一个委托类型来创建一个 LambdaExpression。 |
| Lambda(Expression, ParameterExpression[]) | 通过先构造一个委托类型来创建一个 LambdaExpression。 |
| Lambda(Expression, String, Boolean, IEnumerable |
通过先构造一个委托类型来创建一个 LambdaExpression。 |
| Lambda(Expression, String, IEnumerable |
通过先构造一个委托类型来创建一个 LambdaExpression。 |
| Lambda(Type, Expression, Boolean, IEnumerable |
通过先构造一个委托类型来创建一个 LambdaExpression。 |
| Lambda(Type, Expression, Boolean, ParameterExpression[]) | 通过先构造一个委托类型来创建一个 LambdaExpression。 |
| Lambda(Type, Expression, IEnumerable |
通过先构造一个委托类型来创建一个 LambdaExpression。 如果委托类型在编译时未知，则可以使用它。 |
| Lambda(Type, Expression, ParameterExpression[]) | 通过先构造一个委托类型来创建一个 LambdaExpression。 如果委托类型在编译时未知，则可以使用它。 |
| Lambda(Type, Expression, String, Boolean, IEnumerable |
通过先构造一个委托类型来创建一个 LambdaExpression。 |
| Lambda(Type, Expression, String, IEnumerable |
通过先构造一个委托类型来创建一个 LambdaExpression。 |
| Lambda |
创建一个在编译时委托类型已知的 Expression |
| Lambda |
创建一个在编译时委托类型已知的 Expression |
| Lambda |
创建一个在编译时委托类型已知的 Expression |
| Lambda |
创建一个在编译时委托类型已知的 Expression |
| Lambda |
创建一个在编译时委托类型已知的 Expression |
| Lambda |
创建一个在编译时委托类型已知的 Expression |
| LeftShift(Expression, Expression) | 创建一个表示按位左移运算的 BinaryExpression。 |
| LeftShift(Expression, Expression, MethodInfo) | 创建一个表示按位左移运算的 BinaryExpression。 |
| LeftShiftAssign(Expression, Expression) | 创建一个表示按位左移赋值运算的 BinaryExpression。 |
| LeftShiftAssign(Expression, Expression, MethodInfo) | 创建一个表示按位左移赋值运算的 BinaryExpression。 |
| LeftShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) | 创建一个表示按位左移赋值运算的 BinaryExpression。 |
| LessThan(Expression, Expression) | 创建一个表示“小于”数值比较的 BinaryExpression。 |
| LessThan(Expression, Expression, Boolean, MethodInfo) | 创建一个表示“小于”数值比较的 BinaryExpression。 |
| LessThanOrEqual(Expression, Expression) | 创建一个表示“小于或等于”数值比较的 BinaryExpression。 |
| LessThanOrEqual(Expression, Expression, Boolean, MethodInfo) | 创建一个表示“小于或等于”数值比较的 BinaryExpression。 |
| ListBind(MemberInfo, ElementInit[]) | 创建一个其成员为字段或属性的 MemberListBinding。 |
| ListBind(MemberInfo, IEnumerable |
创建一个其成员为字段或属性的 MemberListBinding。 |
| ListBind(MethodInfo, ElementInit[]) | 基于指定的属性访问器方法创建一个 MemberListBinding 对象。 |
| ListBind(MethodInfo, IEnumerable |
基于指定的属性访问器方法创建一个 MemberListBinding。 |
| ListInit(NewExpression, ElementInit[]) | 创建一个使用指定 ListInitExpression 对象来初始化集合的 ElementInit。 |
| ListInit(NewExpression, Expression[]) | 创建一个使用名为“Add”的方法将元素添加到集合中的ListInitExpression。 |
| ListInit(NewExpression, IEnumerable |
创建一个使用指定 ListInitExpression 对象来初始化集合的 ElementInit。 |
| ListInit(NewExpression, IEnumerable |
创建一个使用名为“Add”的方法将元素添加到集合中的 ListInitExpression。 |
| ListInit(NewExpression, MethodInfo, Expression[]) | 创建一个使用指定方法将元素添加到集合中的 ListInitExpression。 |
| ListInit(NewExpression, MethodInfo, IEnumerable |
创建一个使用指定方法将元素添加到集合中的 ListInitExpression。 |
| Loop(Expression) | 创建具有给定主体的 LoopExpression。 |
| Loop(Expression, LabelTarget) | 创建具有给定主体和中断目标的 LoopExpression。 |
| Loop(Expression, LabelTarget, LabelTarget) | 创建具有给定主体的 LoopExpression。 |
| MakeBinary(ExpressionType, Expression, Expression) | 在给定左操作数和右操作数的情况下，通过调用适当的工厂方法来创建一个 BinaryExpression。 |
| MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo) | 在给定左操作数、右操作数和实现方法的情况下，通过调用适当的工厂方法来创建一个 BinaryExpression。 |
| MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo, LambdaExpression) | 在给定左操作数、右操作数、实现方法和类型转换函数的情况下，通过调用适当的工厂方法来创建一个 BinaryExpression。 |
| MakeCatchBlock(Type, ParameterExpression, Expression, Expression) | 创建一个表示具有指定元素的 catch 语句的 CatchBlock。 |
| MakeDynamic(Type, CallSiteBinder, Expression) | 创建一个 DynamicExpression，它表示由提供的 CallSiteBinder 和一个参数绑定的动态操作。 |
| MakeDynamic(Type, CallSiteBinder, Expression, Expression) | 创建一个 DynamicExpression，它表示由提供的 CallSiteBinder 和两个参数绑定的动态操作。 |
| MakeDynamic(Type, CallSiteBinder, Expression, Expression, Expression) | 创建一个 DynamicExpression，它表示由提供的 CallSiteBinder 和三个参数绑定的动态操作。 |
| MakeDynamic(Type, CallSiteBinder, Expression, Expression, Expression, Expression) | 创建一个 DynamicExpression，它表示由提供的 CallSiteBinder 和四个参数绑定的动态操作。 |
| MakeDynamic(Type, CallSiteBinder, Expression[]) | 创建一个 DynamicExpression，它表示由提供的 CallSiteBinder 绑定的动态操作。 |
| MakeDynamic(Type, CallSiteBinder, IEnumerable |
创建一个 DynamicExpression，它表示由提供的 CallSiteBinder 绑定的动态操作。 |
| MakeGoto(GotoExpressionKind, LabelTarget, Expression, Type) | 创建一个 GotoExpression，它表示指定的 GotoExpressionKind 的跳转。 也可以指定在跳转时传递给标签的值。 |
| MakeIndex(Expression, PropertyInfo, IEnumerable |
创建一个 IndexExpression，它表示访问对象中的索引属性。 |
| MakeMemberAccess(Expression, MemberInfo) | 创建一个表示访问字段或属性的 MemberExpression。 |
| MakeTry(Type, Expression, Expression, Expression, IEnumerable |
创建一个表示具有指定元素的 try 块的 TryExpression。 |
| MakeUnary(ExpressionType, Expression, Type) | 在给定操作数的情况下，通过调用适当的工厂方法来创建一个 UnaryExpression。 |
| MakeUnary(ExpressionType, Expression, Type, MethodInfo) | 在给定操作数和实现方法的情况下，通过调用适当的工厂方法来创建一个 UnaryExpression。 |
| MemberBind(MemberInfo, IEnumerable |
创建一个表示递归初始化某个字段或属性的成员的 MemberMemberBinding。 |
| MemberBind(MemberInfo, MemberBinding[]) | 创建一个表示递归初始化某个字段或属性的成员的 MemberMemberBinding。 |
| MemberBind(MethodInfo, IEnumerable |
使用属性访问器方法创建一个表示对所访问的成员的成员进行递归初始化的 MemberMemberBinding。 |
| MemberBind(MethodInfo, MemberBinding[]) | 使用属性访问器方法创建一个表示对所访问的成员的成员进行递归初始化的 MemberMemberBinding。 |
| MemberInit(NewExpression, IEnumerable |
表示一个表达式，该表达式创建新对象并初始化该对象的一个属性。 |
| MemberInit(NewExpression, MemberBinding[]) | 创建一个 MemberInitExpression。 |
| MemberwiseClone() | 创建当前 Object 的浅表副本。（继承自 Object。） |
| Modulo(Expression, Expression) | 创建一个表示算术余数运算的 BinaryExpression。 |
| Modulo(Expression, Expression, MethodInfo) | 创建一个表示算术余数运算的 BinaryExpression。 |
| ModuloAssign(Expression, Expression) | 创建一个表示余数赋值运算的 BinaryExpression。 |
| ModuloAssign(Expression, Expression, MethodInfo) | 创建一个表示余数赋值运算的 BinaryExpression。 |
| ModuloAssign(Expression, Expression, MethodInfo, LambdaExpression) | 创建一个表示余数赋值运算的 BinaryExpression。 |
| Multiply(Expression, Expression) | 创建一个表示不进行溢出检查的算术乘法运算的 BinaryExpression。 |
| Multiply(Expression, Expression, MethodInfo) | 创建一个表示不进行溢出检查的算术乘法运算的 BinaryExpression。 |
| MultiplyAssign(Expression, Expression) | 创建一个表示不进行溢出检查的乘法赋值运算的 BinaryExpression。 |
| MultiplyAssign(Expression, Expression, MethodInfo) | 创建一个表示不进行溢出检查的乘法赋值运算的 BinaryExpression。 |
| MultiplyAssign(Expression, Expression, MethodInfo, LambdaExpression) | 创建一个表示不进行溢出检查的乘法赋值运算的 BinaryExpression。 |
| MultiplyAssignChecked(Expression, Expression) | 创建一个表示进行溢出检查的乘法赋值运算的 BinaryExpression。 |
| MultiplyAssignChecked(Expression, Expression, MethodInfo) | 创建一个表示进行溢出检查的乘法赋值运算的 BinaryExpression。 |
| MultiplyAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) | 创建一个表示进行溢出检查的乘法赋值运算的 BinaryExpression。 |
| MultiplyChecked(Expression, Expression) | 创建一个表示进行溢出检查的算术乘法运算的 BinaryExpression。 |
| MultiplyChecked(Expression, Expression, MethodInfo) | 创建一个表示进行溢出检查的算术乘法运算的 BinaryExpression。 |
| Negate(Expression) | 创建一个表示算术求反运算的 UnaryExpression。 |
| Negate(Expression, MethodInfo) | 创建一个表示算术求反运算的 UnaryExpression。 |
| NegateChecked(Expression) | 创建一个表示进行溢出检查的算术求反运算的 UnaryExpression。 |
| NegateChecked(Expression, MethodInfo) | 创建一个表示进行溢出检查的算术求反运算的 UnaryExpression。 可指定实现方法。 |
| New(ConstructorInfo) | 创建一个表示调用不带参数的指定构造函数的 NewExpression。 |
| New(ConstructorInfo, Expression[]) | 创建一个表示调用带指定参数的指定构造函数的 NewExpression。 |
| New(ConstructorInfo, IEnumerable |
创建一个表示调用带指定参数的指定构造函数的 NewExpression。 |
| New(ConstructorInfo, IEnumerable |
创建一个表示调用带指定参数的指定构造函数的 NewExpression。 其中指定了访问构造函数初始化的字段的成员。 |
| New(ConstructorInfo, IEnumerable |
创建一个表示调用带指定参数的指定构造函数的 NewExpression。 将访问构造函数初始化字段的成员指定为数组。 |
| New(Type) | 创建一个表示调用指定类型的无参数构造函数的 NewExpression。 |
| NewArrayBounds(Type, Expression[]) | 创建一个表示创建具有指定秩的数组的 NewArrayExpression。 |
| NewArrayBounds(Type, IEnumerable |
创建一个表示创建具有指定秩的数组的 NewArrayExpression。 |
| NewArrayInit(Type, Expression[]) | 创建一个表示创建一维数组并使用元素列表初始化该数组的 NewArrayExpression。 |
| NewArrayInit(Type, IEnumerable |
创建一个表示创建一维数组并使用元素列表初始化该数组的 NewArrayExpression。 |
| Not(Expression) | 创建一个表示按位求补运算的 UnaryExpression。 |
| Not(Expression, MethodInfo) | 创建一个表示按位求补运算的 UnaryExpression。 可指定实现方法。 |
| NotEqual(Expression, Expression) | 创建一个表示不相等比较的 BinaryExpression。 |
| NotEqual(Expression, Expression, Boolean, MethodInfo) | 创建一个表示不相等比较的 BinaryExpression。 |
| OnesComplement(Expression) | 返回表示一的补数的表达式。 |
| OnesComplement(Expression, MethodInfo) | 返回表示一的补数的表达式。 |
| Or(Expression, Expression) | 创建一个表示按位 BinaryExpression 运算的 OR。 |
| Or(Expression, Expression, MethodInfo) | 创建一个表示按位 BinaryExpression 运算的 OR。 |
| OrAssign(Expression, Expression) | 创建一个表示按位 OR 赋值运算的 BinaryExpression。 |
| OrAssign(Expression, Expression, MethodInfo) | 创建一个表示按位 OR 赋值运算的 BinaryExpression。 |
| OrAssign(Expression, Expression, MethodInfo, LambdaExpression) | 创建一个表示按位 OR 赋值运算的 BinaryExpression。 |
| OrElse(Expression, Expression) | 创建一个 BinaryExpression，它表示仅在第一个操作数的计算结果为 OR 时才计算第二个操作数的条件 false 运算。 |
| OrElse(Expression, Expression, MethodInfo) | 创建一个 BinaryExpression，它表示仅在第一个操作数的计算结果为 OR 时才计算第二个操作数的条件 false 运算。 |
| Parameter(Type) | 创建一个 ParameterExpression 节点，该节点可用于标识表达式树中的参数或变量。 |
| Parameter(Type, String) | 创建一个 ParameterExpression 节点，该节点可用于标识表达式树中的参数或变量。 |
| PostDecrementAssign(Expression) | 创建一个 UnaryExpression，它表示将原始表达式递减 1 之后再进行表达式赋值。 |
| PostDecrementAssign(Expression, MethodInfo) | 创建一个 UnaryExpression，它表示将原始表达式递减 1 之后再进行表达式赋值。 |
| PostIncrementAssign(Expression) | 创建一个 UnaryExpression，它表示将原始表达式递增 1 之后再进行表达式赋值。 |
| PostIncrementAssign(Expression, MethodInfo) | 创建一个 UnaryExpression，它表示将原始表达式递增 1 之后再进行表达式赋值。 |
| Power(Expression, Expression) | 创建一个表示对数进行幂运算的 BinaryExpression。 |
| Power(Expression, Expression, MethodInfo) | 创建一个表示对数进行幂运算的 BinaryExpression。 |
| PowerAssign(Expression, Expression) | 创建一个 BinaryExpression，它表示对表达式求幂并将结果赋回给表达式。 |
| PowerAssign(Expression, Expression, MethodInfo) | 创建一个 BinaryExpression，它表示对表达式求幂并将结果赋回给表达式。 |
| PowerAssign(Expression, Expression, MethodInfo, LambdaExpression) | 创建一个 BinaryExpression，它表示对表达式求幂并将结果赋回给表达式。 |
| PreDecrementAssign(Expression) | 创建一个 UnaryExpression，它将表达式递减 1 并将结果赋回给表达式。 |
| PreDecrementAssign(Expression, MethodInfo) | 创建一个 UnaryExpression，它将表达式递减 1 并将结果赋回给表达式。 |
| PreIncrementAssign(Expression) | 创建一个 UnaryExpression，它将表达式递增 1 并将结果赋回给表达式。 |
| PreIncrementAssign(Expression, MethodInfo) | 创建一个 UnaryExpression，它将表达式递增 1 并将结果赋回给表达式。 |
| Property(Expression, MethodInfo) | 使用属性访问器方法创建一个表示访问属性的 MemberExpression。 |
| Property(Expression, PropertyInfo) | 创建一个表示访问属性的 MemberExpression。 |
| Property(Expression, PropertyInfo, Expression[]) | 创建一个 IndexExpression，它表示对索引属性的访问。 |
| Property(Expression, PropertyInfo, IEnumerable |
创建一个 IndexExpression，它表示对索引属性的访问。 |
| Property(Expression, String) | 创建一个表示访问属性的 MemberExpression。 |
| Property(Expression, String, Expression[]) | 创建一个 IndexExpression，它表示对索引属性的访问。 |
| Property(Expression, Type, String) | 创建一个访问属性的 MemberExpression。 |
| PropertyOrField(Expression, String) | 创建一个表示访问属性或字段的 MemberExpression。 |
| Quote(Expression) | 创建一个表示具有类型 UnaryExpression 的常量值的表达式的 Expression。 |
| Reduce() | 将此节点简化为更简单的表达式。 如果 CanReduce 返回 true，则它应返回有效的表达式。 此方法可以返回本身必须简化的另一个节点。 |
| ReduceAndCheck() | 将此节点简化为更简单的表达式。 如果 CanReduce 返回 true，则它应返回有效的表达式。 此方法可以返回本身必须简化的另一个节点。 |
| ReduceExtensions() | 将表达式简化为已知节点类型（即非 Extension 节点）或仅在此类型为已知类型时返回表达式。 |
| ReferenceEqual(Expression, Expression) | 创建一个表示引用相等比较的 BinaryExpression。 |
| ReferenceNotEqual(Expression, Expression) | 创建一个表示引用不相等比较的 BinaryExpression。 |
| Rethrow() | 创建一个 UnaryExpression，它表示重新引发异常。 |
| Rethrow(Type) | 创建一个 UnaryExpression，它表示重新引发具有给定类型的异常。 |
| Return(LabelTarget) | 创建一个表示 return 语句的 GotoExpression。 |
| Return(LabelTarget, Expression) | 创建一个表示 return 语句的 GotoExpression。 可以指定在跳转时传递给标签的值。 |
| Return(LabelTarget, Expression, Type) | 创建一个表示具有指定类型的 return 语句的 GotoExpression。 可以指定在跳转时传递给标签的值。 |
| Return(LabelTarget, Type) | 创建一个表示具有指定类型的 return 语句的 GotoExpression。 |
| RightShift(Expression, Expression) | 创建一个表示按位右移运算的 BinaryExpression。 |
| RightShift(Expression, Expression, MethodInfo) | 创建一个表示按位右移运算的 BinaryExpression。 |
| RightShiftAssign(Expression, Expression) | 创建一个表示按位右移赋值运算的 BinaryExpression。 |
| RightShiftAssign(Expression, Expression, MethodInfo) | 创建一个表示按位右移赋值运算的 BinaryExpression。 |
| RightShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) | 创建一个表示按位右移赋值运算的 BinaryExpression。 |
| RuntimeVariables(IEnumerable |
创建 RuntimeVariablesExpression 的实例。 |
| RuntimeVariables(ParameterExpression[]) | 创建 RuntimeVariablesExpression 的实例。 |
| Subtract(Expression, Expression) | 创建一个表示不进行溢出检查的算术减法运算的 BinaryExpression。 |
| Subtract(Expression, Expression, MethodInfo) | 创建一个表示不进行溢出检查的算术减法运算的 BinaryExpression。 |
| SubtractAssign(Expression, Expression) | 创建一个表示不进行溢出检查的减法赋值运算的 BinaryExpression。 |
| SubtractAssign(Expression, Expression, MethodInfo) | 创建一个表示不进行溢出检查的减法赋值运算的 BinaryExpression。 |
| SubtractAssign(Expression, Expression, MethodInfo, LambdaExpression) | 创建一个表示不进行溢出检查的减法赋值运算的 BinaryExpression。 |
| SubtractAssignChecked(Expression, Expression) | 创建一个表示进行溢出检查的减法赋值运算的 BinaryExpression。 |
| SubtractAssignChecked(Expression, Expression, MethodInfo) | 创建一个表示进行溢出检查的减法赋值运算的 BinaryExpression。 |
| SubtractAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) | 创建一个表示进行溢出检查的减法赋值运算的 BinaryExpression。 |
| SubtractChecked(Expression, Expression) | 创建一个表示进行溢出检查的算术减法运算的 BinaryExpression。 |
| SubtractChecked(Expression, Expression, MethodInfo) | 创建一个表示进行溢出检查的算术减法运算的 BinaryExpression。 |
| Switch(Expression, Expression, MethodInfo, IEnumerable |
创建一个表示具有默认分支的 SwitchExpression 语句的 switch。 |
| Switch(Expression, Expression, MethodInfo, SwitchCase[]) | 创建一个表示具有默认分支的 SwitchExpression 语句的 switch。 |
| Switch(Expression, Expression, SwitchCase[]) | 创建一个表示具有默认分支的 SwitchExpression 语句的 switch。 |
| Switch(Expression, SwitchCase[]) | 创建一个表示不带默认分支的 SwitchExpression 语句的 switch。 |
| Switch(Type, Expression, Expression, MethodInfo, IEnumerable |
创建一个表示具有默认分支的 SwitchExpression 语句的 switch。 |
| Switch(Type, Expression, Expression, MethodInfo, SwitchCase[]) | 创建一个 SwitchExpression，它表示具有默认分支的 switch 语句。 |
| SwitchCase(Expression, Expression[]) | 创建在 SwitchCase 中使用的 SwitchExpression。 |
| SwitchCase(Expression, IEnumerable |
创建要在 SwitchCase 对象中使用的 SwitchExpression 对象。 |
| SymbolDocument(String) | 创建 SymbolDocumentInfo 的实例。 |
| SymbolDocument(String, Guid) | 创建 SymbolDocumentInfo 的实例。 |
| SymbolDocument(String, Guid, Guid) | 创建 SymbolDocumentInfo 的实例。 |
| SymbolDocument(String, Guid, Guid, Guid) | 创建 SymbolDocumentInfo 的实例。 |
| Throw(Expression) | 创建一个 UnaryExpression，它表示引发异常。 |
| Throw(Expression, Type) | 创建一个 UnaryExpression，它表示引发具有给定类型的异常。 |
| ToString() | 返回 Expression 的的文本化表示形式。（覆盖 Object.ToString()。） |
| TryCatch(Expression, CatchBlock[]) | 创建一个表示 try 块的 TryExpression，该 try 块包含任意数量的 catch 语句，但不包含 fault 和 finally 块。 |
| TryCatchFinally(Expression, Expression, CatchBlock[]) | 创建一个表示 try 块的 TryExpression，该 try 块包含任意数量的 catch 语句和一个 finally 块。 |
| TryFault(Expression, Expression) | 创建一个表示 try 块的 TryExpression，该 try 块包含一个 fault 块，但不包含 catch 语句。 |
| TryFinally(Expression, Expression) | 创建一个表示 try 块的 TryExpression，该 try 块包含一个 finally 块，但不包含 catch 语句。 |
| TryGetActionType(Type[], Type) | 创建一个 Type 对象，它表示具有特定类型参数的泛型 System.Action 委托类型。 |
| TryGetFuncType(Type[], Type) | 创建一个 Type 对象，它表示具有特定类型参数的泛型 System.Func 委托类型。 最后一个类型参数指定已创建委托的返回类型。 |
| TypeAs(Expression, Type) | 创建一个表示显式引用或装箱转换的 UnaryExpression（如果转换失败，则提供 null）。 |
| TypeEqual(Expression, Type) | 创建一个比较运行时类型标识的 TypeBinaryExpression。 |
| TypeIs(Expression, Type) | 创建一个 TypeBinaryExpression。 |
| UnaryPlus(Expression) | 创建一个表示一元正运算的 UnaryExpression。 |
| UnaryPlus(Expression, MethodInfo) | 创建一个表示一元正运算的 UnaryExpression。 |
| Unbox(Expression, Type) | 创建一个表示显式取消装箱的 UnaryExpression。 |
| Variable(Type) | 创建一个 ParameterExpression 节点，该节点可用于标识表达式树中的参数或变量。 |
| Variable(Type, String) | 创建一个 ParameterExpression 节点，该节点可用于标识表达式树中的参数或变量。 |
| VisitChildren(ExpressionVisitor) | 简化节点，然后对简化的表达式调用访问者委托。 该方法在节点不可简化时引发异常。 |
总结
其实λ表达式树并不难，看上去很高深的东西，只有理解了其中的原理，还是很快可以上手的！毕竟在实际项目中还是很广泛应用的，掌握λ表达式树打一套组合拳，就能够实现各种各样的应用，甚至动态编译！
λ表达式树的实际应用案例
给EF Core增加AddOrUpdate方法：https://masuit.com/1741
给linq增加And和Or扩展：https://github.com/ldqk/Masuit.Tools/blob/master/Masuit.Tools/Linq/LinqExtension.cs
通过λ表达式树自己实现一个AutoMapper：https://github.com/ldqk/Masuit.Tools/blob/master/Masuit.Tools/Mapping/ExpressionMapper.cs
通过λ表达式树实现对象的深克隆：https://github.com/ldqk/Masuit.Tools/blob/master/Masuit.Tools/Mapping/ExpressionCpoier.cs
将字符串转换成λ表达式的项目：https://github.com/zzzprojects/Eval-Expression.NET
将字符串转换成动态Linq：https://github.com/zzzprojects/System.Linq.Dynamic
动态组合条件表达式：https://github.com/dbelmont/ExpressionBuilder
还有很多很多这样的项目和应用，这里就不再一一列举了，LinqToAnything！λ表达式树是linq的基石，linq是万能的！
最后，给大家留几个思考题吧
1. Expression.Lambda(Expression.Parameter(typeof(int), "x"), Expression.Parameter(typeof(int), "x"))这种写法有没有问题？为什么？
2. 使用λ表达式树如何自己实现一个字符串算式的计算，如输入："5x3+4"，输出15？