有看过我之前发表过的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<int, int, int> func1 = new Func<int, int, int>((int m, int n) =>
{
return m * n + 2;
});
//对其进行最简化(Lambda语句)
Func<int, int, int> func2 = (m, n) =>
{
return m * n + 2;
};
//对其进行最简化(Lambda表达式)
Func<int, int, int> 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<Func<int,int>>(inc,x);// 将表达式树组装成lambda表达式树，一个输入，一个输出，故Func<int,int>
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<Func<int, int, int>>(add, a, b);// 将表达式树组装成lambda表达式树，两个输入，一个输出，故Func<int, int, int>
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<Func<double, double, double, double, double, double>>(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<string> 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<Func<MyClass>>(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<Func<MyClass, string>>(property, e);
为属性赋值e=>e.List=new List<string>(){"sdf"}
结合上面的属性操作，既然能获取属性，那就一定能设置属性值，Expression.Assign操作便是赋值操作
var newExpression = Expression.New(typeof(MyClass).GetConstructor(new[] { typeof(int) }), Expression.Constant(100)); // 有参构造函数方式
var lambda = Expression.Lambda<Func<MyClass>>(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<string>() { "sdf" }));//为集合类型的属性赋值
Expression.Lambda<Action<MyClass>>(assignList, e).Compile()(myClass);
Expression.Lambda<Action<MyClass>>(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<Func<MyClass, int>>(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<Func<MyClass, string>>(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<Func<MyClass, bool>>(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<Func<MyClass, bool>>(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<Func<int, string>>(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<Func<MyClass, string>>(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<Func<MyClass, string>>(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<Func<int>>(convert);
声明一个数组对象
Expression.NewArrayBounds即可生成一个创建数组对象的表达式：
var array = Expression.NewArrayBounds(typeof(string), Expression.Constant(5));
var lambda = Expression.Lambda<Func<string[]>>(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<Func<MyClass, bool>>(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<Func<MyClass, bool>>(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<SampleType>(){ a, b, c } 在 C# 或 Dim sampleList = { a, b, c } 在 Visual Basic 中。 |
| 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的操作方法
总结
其实λ表达式树并不难，看上去很高深的东西，只有理解了其中的原理，还是很快可以上手的！毕竟在实际项目中还是很广泛应用的，掌握λ表达式树打一套组合拳，就能够实现各种各样的应用，甚至动态编译！
λ表达式树的实际应用案例
给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？
774
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
