本人之前从未接触过表达式树的概念，所以特意从网上找到两篇这方面的资料学习了下。本文为阅读笔记性质博客！
表达式树是.NET 3.5之后引入的，它是一个强大灵活的工具（比如用在LINQ中构造动态查询）。
先来看看Expression类的API接口：
using System.Collections.ObjectModel;
namespace System.Linq.Expressions
{
// Summary:
// Represents a strongly typed lambda expression as a data structure in the
// form of an expression tree. This class cannot be inherited.
//
// Type parameters:
// TDelegate:
// The type of the delegate that the System.Linq.Expressions.Expression<tdelegate>
// represents.
public sealed class Expression<tdelegate> : LambdaExpression
{
// Summary:
// Compiles the lambda expression described by the expression tree into executable
// code.
//
// Returns:
// A delegate of type TDelegate that represents the lambda expression described
// by the System.Linq.Expressions.Expression<tdelegate>.
public TDelegate Compile();
}
}
表达式树的语法如下：
Expression<Func<type,returnType>> = (param) => lamdaexpresion;
我们先来看一个简单例子：
Expression<Func<int, int, int>> expr = (x, y) => x+y;
这就是一个表达式树了。使用Expression Tree Visualizer工具（直接调试模式下看也可以，只不过没这个直观）在调试模式下查看这个表达式树（就是一个对象），如下：
可以看到表达式树主要由下面四部分组成：
1、Body 主体部分
2、Parameters 参数部分
3、NodeType 节点类型
4、Lambda表达式类型
对于前面举的例子，主体部分即x+y，参数部分即(x,y)。Lambda表达式类型是Func<Int32, Int32, Int32>。注意主体部分可以是表达式，但是不能包含语句，如下这样：
Expression<Func<int, int, int>> expr = (x, y) => { return x+y; };
用前面的方法虽然可以创建表达式树，但是不够灵活，如果要灵活构建表达式树，可以像下面这样：
ParameterExpression exp1 = Expression.Parameter(typeof(int), "a");
ParameterExpression exp2 = Expression.Parameter(typeof(int), "b");
BinaryExpression exp = Expression.Multiply(exp1,exp2);
var lamExp = Expression.Lambda<Func<int, int, int>>(exp, new ParameterExpression[] { exp1, exp2 });
exp1、exp2即表达式树的参数，exp是表达式树的主体。如果我利用Reflector反编译Expression<Func<int, int, int>> expr = (x, y) => { return x+y; };得到下面的C#代码：
ParameterExpression CS$0$0000;
ParameterExpression CS$0$0001;
Expression<Func<int, int, int>> expr = Expression.Lambda<Func<int, int, int>>(Expression.Multiply(CS$0$0000 = Expression.Parameter(typeof(int), "x"), CS$0$0001 = Expression.Parameter(typeof(int), "y")), new ParameterExpression[] { CS$0$0000, CS$0$0001 });
可以看到它基本和上面的手动构建代码一致。再来看一个简单的例子：
Expression<Func<Customer, bool>> filter =
cust => Equal(Property(cust,"Region"),"North");
可以用下面的代码手动构建效果等同于上面的表达式树：
// declare a parameter of type Customer named cust
ParameterExpression custParam = Expression.Parameter(
typeof(Customer), "custParam");
// compare (equality) the Region property of the
// parameter against the string constant "North"
BinaryExpression body = Expression.Equal(
Expression.Property(custParam, "Region"),
Expression.Constant("North", typeof(string)));
// formalise this as a lambda
Expression<Func<Customer, bool>> filter =
Expression.Lambda<Func<Customer, bool>>(body, cust);
然后我们可以通过表达式树的Compile方法将表达式树编译成Lambda表达式，如下：
Func<Customer, bool> filterFunc = filter.Compile();
但是Compile调用过程涉及动态代码生成，所以出于性能考虑最好只调用一次，然后缓存起来。或者像下面这样在静态构造块中使用（也只会调用一次）：
public static class Operator<T>
{
private static readonly Func<T, T, T> add;
public static T Add(T x, T y)
{
return add(x, y);
}
static Operator()
{
var x = Expression.Parameter(typeof(T), "x");
var y = Expression.Parameter(typeof(T), "y");
var body = Expression.Add(x, y);
add = Expression.Lambda<Func<T, T, T>>(
body, x, y).Compile();
}
}
Expression类包含下面几类静态方法(.NET 3.5中）：
Arithmetic: Add, AddChecked, Divide, Modulo, Multiply, MultiplyChecked, Negate, NegateChecked, Power,
Subtract, SubtractChecked, UnaryPlus
Creation: Bind, ElementInit, ListBind, ListInit, MemberBind, MemberInit, New, NewArrayBounds, NewArrayInit
Bitwise: And, ExclusiveOr, LeftShift (<<), Not, Or, RightShift (>>)
Logical: AndAlso (&&), Condition (? :), Equal, GreaterThan, GreaterThanOrEqual, LessThan,
LessThanOrEqual, NotEqual, OrElse (||), TypeIs
Member Access: ArrayIndex, ArrayLength, Call, Field, Property, PropertyOrField
Other: Convert, ConvertChecked, Coalesce (??), Constant, Invoke, Lambda, Parameter, TypeAs, Quote
下面我们类似前面重载一个浅拷贝的例子（比使用反射开销小）：
using System;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
namespace ExpressionTreeLab
{
class Program
{
static void Main(string[] args)
{
var p = new Person()
{
Name = "jxq",
Age = 23
};
var shallowCopy = Operator<Person>.ShallowCopy(p);
shallowCopy.Name = "feichexia";
Console.WriteLine(shallowCopy.Name);
Console.WriteLine(p.Name);
Console.ReadKey();
}
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
public static class Operator<T>
{
private static readonly Func<T, T> ShallowClone;
public static T ShallowCopy(T sourcObj)
{
return ShallowClone.Invoke(sourcObj);
}
static Operator()
{
var origParam = Expression.Parameter(typeof(T), "orig");
// for each read/write property on T, create a new binding
// (for the object initializer) that copies the original's value into the new object
var setProps = from prop in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance)
where prop.CanRead && prop.CanWrite
select (MemberBinding)Expression.Bind(prop, Expression.Property(origParam, prop));
var body = Expression.MemberInit( // object initializer
Expression.New(typeof(T)), // ctor
setProps // property assignments
);
ShallowClone = Expression.Lambda<Func<T, T>>(body, origParam).Compile();
}
}
}
}
继续看Expression.AndAlso的使用，它可以用来替代类似下面这种多条件与的情况：
Func<Person, Person, bool> personEqual = (person1, person2) => person1.Name == person2.Name && person1.Age == person2.Age;
if(personEqual(p1, p2))
{
Console.WriteLine("两个对象所有属性值都相等！");
}
代码如下：
using System;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
namespace ExpressionTreeLab
{
class Program
{
static void Main(string[] args)
{
var p1 = new Person()
{
Name = "jxq",
Age = 23
};
var p2 = new Person()
{
Name = "jxq",
Age = 23
};
if (Operator<Person>.ObjectPropertyEqual(p1, p2))
{
Console.WriteLine("两个对象所有属性值都相等！");
}
Console.ReadKey();
}
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
public static class Operator<T>
{
private static readonly Func<T, T, bool> PropsEqual;
public static bool ObjectPropertyEqual(T obj1, T obj2)
{
return PropsEqual.Invoke(obj1, obj2);
}
static Operator()
{
var x = Expression.Parameter(typeof(T), "x");
var y = Expression.Parameter(typeof(T), "y");
// 获取类型T上的可读Property
var readableProps = from prop in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance)
where prop.CanRead
select prop;
Expression combination = null;
foreach (var readableProp in readableProps)
{
var thisPropEqual = Expression.Equal(Expression.Property(x, readableProp),
Expression.Property(y, readableProp));
if(combination == null)
{
combination = thisPropEqual;
}
else
{
combination = Expression.AndAlso(combination, thisPropEqual);
}
}
if(combination == null) // 如果没有需要比较的东西，直接返回false
{
PropsEqual = (p1, p2) => false;
}
else
{
PropsEqual = Expression.Lambda<Func<T, T, bool>>(combination, x, y).Compile();
}
}
}
}
}
在.NET 4.0中扩展了一些Expression的静态方法，使得编写动态代码更容易：
Mutation: AddAssign, AddAssignChecked, AndAssign, Assign, DivideAssign, ExclusiveOrAssign, LeftShiftAssign, ModuloAssign, MultiplyAssign, MultiplyAssignChecked, OrAssign, PostDecrementAssign, PostIncrementAssign, PowerAssign, PreDecrementAssign, PreIncrementAssign, RightShiftAssign, SubtractAssign, SubtractAssignChecked
Arithmetic: Decrement, Default, Increment, OnesComplement
Member Access: ArrayAccess, Dynamic
Logical: ReferenceEqual, ReferenceNotEqual, TypeEqual
Flow: Block, Break, Continue, Empty, Goto, IfThen, IfThenElse, IfFalse, IfTrue, Label, Loop, Return, Switch, SwitchCase, Unbox, Variable
Exceptions: Catch, Rethrow, Throw
Debug: ClearDebugInfo, DebugInfo
下面是一个利用表达式树编写动态代码的例子（循环打印0到9）：
using System;
using System.Linq.Expressions;
namespace ExpressionTreeLab
{
class Program
{
static void Main(string[] args)
{
var exitFor = Expression.Label("exitFor"); // jump label
var x = Expression.Variable(typeof(int), "x");
var body =
Expression.Block(
new[] { x }, // declare scope variables
Expression.Assign(x, Expression.Constant(0, typeof(int))), // init
Expression.Loop(
Expression.IfThenElse(
Expression.GreaterThanOrEqual( // test for exit
x,
Expression.Constant(10, typeof(int))
),
Expression.Break(exitFor), // perform exit
Expression.Block( // perform code
Expression.Call(
typeof(Console), "WriteLine", null, x),
Expression.PostIncrementAssign(x)
)
), exitFor
) // Loop ends
);
var runtimeLoop = Expression.Lambda<Action>(body).Compile();
runtimeLoop();
Console.Read();
}
}
}
另外WhereIn扩展实现如下，如果前面的例子都熟悉了的话，这个自然也很容易看懂了：
/// <summary>
/// 使之支持Sql in语法
/// </summary>
/// <typeparam name = "T"></typeparam>
/// <typeparam name = "TValue"></typeparam>
/// <param name = "query"></param>
/// <param name = "obj"></param>
/// <param name = "values"></param>
/// <returns></returns>
public static IQueryable<T> WhereIn<T, TValue>(this IQueryable<T> query, Expression<Func<T, TValue>> obj, IEnumerable<TValue> values)
{
return query.Where(BuildContainsExpression(obj, values));
}
private static Expression<Func<TElement, bool>> BuildContainsExpression<TElement, TValue>(
Expression<Func<TElement, TValue>> valueSelector, IEnumerable<TValue> values)
{
if (null == valueSelector)
{
throw new ArgumentNullException("valueSelector");
}
if (null == values)
{
throw new ArgumentNullException("values");
}
var p = valueSelector.Parameters.Single();
if (!values.Any()) return e => false;
var equals = values.Select(value => (Expression) Expression.Equal(valueSelector.Body, Expression.Constant(value, typeof (TValue))));
var body = equals.Aggregate(Expression.Or);
return Expression.Lambda<Func<TElement, bool>>(body, p);
}
调用方式如下：
db.Users.WhereIIn(u => u.Id, new int[] { 1, 2, 3 });
关于使用表达式树构建LINQ动态查询，请参考Dynamic Linq Queries with Expression Trees
参考资料：