表达式目录树（源MSDN） （可以用类来分析表达式树）

今天在翻看MSDN时遇到个词组“表达式目录树”，不明白是什么意思。为此，链接到相关的章节狠狠的补了补！

1、定义：

表达式目录树以数据形式表示语言级别代码。数据存储在树形结构中。表达式目录树中的每个节点都表示一个表达式，例如一个方法调用或诸如 x < y 的二元运算。

下面的插图显示一个表达式及其表达式目录树形式的表示形式的示例。表达式的不同部分进行了颜色编码，以便与表达式目录树中相应的表达式目录树节点匹配。此外，还显示了不同类型的表达式目录树节点。

2、分解表达式目录树（取得表达式树的节点）

下面的代码示例演示如何将表示 lambda 表达式 num => num < 5 (C#) 的表达式目录树分解为它的部分。。

// using System.Linq.Expressions;// Create an expression tree.Expression<Func<int, bool>> exprTree = num => num < 5;// Decompose the expression tree.ParameterExpression param = (ParameterExpression)exprTree.Parameters[0];BinaryExpression operation = (BinaryExpression)exprTree.Body;ParameterExpression left = (ParameterExpression)operation.Left;ConstantExpression right = (ConstantExpression)operation.Right;Console.WriteLine("Decomposed expression: {0} => {1} {2} {3}",                  param.Name, left.Name, operation.NodeType, right.Value);/*  This code produces the following output:    Decomposed expression: num => num LessThan 5*/

3、生成表达式目录树

System.Linq.Expressions 命名空间提供用于手动生成表达式目录树的 API。Expression 类包含创建特定类型的表达式目录树节点的静态工厂方法，例如，ParameterExpression（表示一个已命名的参数表达式）或 MethodCallExpression（表示一个方法调用）。System.Linq.Expressions 命名空间中还定义了 ParameterExpression、MethodCallExpression 和其他特定于表达式的表达式目录树类型。这些类型派生自抽象类型 Expression。

编译器也可以为您生成表达式目录树。编译器生成的表达式目录树的根始终在类型 Expression<(Of <(TDelegate>)>) 的节点中；也就是说，其根节点表示一个 lambda 表达式。

下面的代码示例演示创建表示 lambda 表达式 num => num < 5 (C#) 表达式目录树的方法。

// Manually build the expression tree for // the lambda expression num => num < 5.ParameterExpression numParam = Expression.Parameter(typeof(int), "num");ConstantExpression five = Expression.Constant(5, typeof(int));BinaryExpression numLessThanFive = Expression.LessThan(numParam, five);Expression<Func<int, bool>> lambda1 =    Expression.Lambda<Func<int, bool>>(        numLessThanFive,        new ParameterExpression[] { numParam });// Let the compiler generate the expression tree for// the lambda expression num => num < 5.Expression<Func<int, bool>> lambda2 = num => num < 5;

表达式目录树是不可变的。这意味着，如果需要修改某个表达式目录树，则必须通过复制现有的表达式目录树并对其进行修改来构造一个新的表达式目录树。您可以使用表达式目录树访问器来遍历现有表达式目录树。

4、修改表达式目录树

若要更改表达式目录树，必须创建现有表达式目录树的一个副本，并在创建副本的过程中执行所需更改。您可以使用表达式目录树访问器遍历现有表达式目录树，并复制它访问的每个节点

例：AndAlsoModifier 类修改二元and表达式

该类继承 ExpressionVisitor 类，并且专用于修改表示条件 AND 运算的表达式。它将这些运算从条件 AND 更改为条件 OR。为此，该类将重写基类型的 VisitBinary 方法，这是因为条件 AND 表达式表示为二元表达式。在 VisitBinary 方法中，如果传递到该方法的表达式表示条件 AND 运算，代码将构造一个包含条件 OR 运算符（而不是条件 AND 运算符）的新表达式。如果传递到 VisitBinary 的表达式不表示条件 AND 运算，则该方法交由基类实现来处理。基类方法构造类似于传入的表达式目录树的节点，但这些节点将其子目录树替换为访问器递归生成的表达式目录树。

public class AndAlsoModifier : ExpressionVisitor{    public Expression Modify(Expression expression)    {        return Visit(expression);    }    protected override Expression VisitBinary(BinaryExpression b)    {        if (b.NodeType == ExpressionType.AndAlso)        {            Expression left = this.Visit(b.Left);            Expression right = this.Visit(b.Right);            // Make this binary expression an OrElse operation instead of an AndAlso operation.            return Expression.MakeBinary(ExpressionType.OrElse, left, right, b.IsLiftedToNull, b.Method);        }        return base.VisitBinary(b);    }}

//调试代码

Expression<Func<string, bool>> expr = name => name.Length > 10 && name.StartsWith("G");Console.WriteLine(expr);AndAlsoModifier treeModifier = new AndAlsoModifier();Expression modifiedExpr = treeModifier.Modify((Expression) expr);Console.WriteLine(modifiedExpr);/*  This code produces the following output:    name => ((name.Length > 10) && name.StartsWith("G"))    name => ((name.Length > 10) || name.StartsWith("G"))*/

5、实现表达式目录树访问器

在表达式目录树访问器实现中，应首先调用的 Visit 方法，该方法基于表达式的类型调度传递到类中更专门的访问器方法之一的表达式。专门的访问器方法访问传递它们的表达式的子树。例如，如果派生类的重写方法访问某个子表达式后，该子表达式发生了更改，则专门的访问器方法会创建一个包含子树中的更改的新表达式。否则，这些方法返回传递它们的表达式。此递归行为可以生成新的表达式目录树，新的表达式目录树或者与传递到 Visit 中的原始表达式版本相同，或者为其修改后的版本。

public abstract class ExpressionVisitor{    protected ExpressionVisitor()    {    }    protected virtual Expression Visit(Expression exp)    {        if (exp == null)            return exp;        switch (exp.NodeType)        {            case ExpressionType.Negate:            case ExpressionType.NegateChecked:            case ExpressionType.Not:            case ExpressionType.Convert:            case ExpressionType.ConvertChecked:            case ExpressionType.ArrayLength:            case ExpressionType.Quote:            case ExpressionType.TypeAs:                return this.VisitUnary((UnaryExpression)exp);            case ExpressionType.Add:            case ExpressionType.AddChecked:            case ExpressionType.Subtract:            case ExpressionType.SubtractChecked:            case ExpressionType.Multiply:            case ExpressionType.MultiplyChecked:            case ExpressionType.Divide:            case ExpressionType.Modulo:            case ExpressionType.And:            case ExpressionType.AndAlso:            case ExpressionType.Or:            case ExpressionType.OrElse:            case ExpressionType.LessThan:            case ExpressionType.LessThanOrEqual:            case ExpressionType.GreaterThan:            case ExpressionType.GreaterThanOrEqual:            case ExpressionType.Equal:            case ExpressionType.NotEqual:            case ExpressionType.Coalesce:            case ExpressionType.ArrayIndex:            case ExpressionType.RightShift:            case ExpressionType.LeftShift:            case ExpressionType.ExclusiveOr:                return this.VisitBinary((BinaryExpression)exp);            case ExpressionType.TypeIs:                return this.VisitTypeIs((TypeBinaryExpression)exp);            case ExpressionType.Conditional:                return this.VisitConditional((ConditionalExpression)exp);            case ExpressionType.Constant:                return this.VisitConstant((ConstantExpression)exp);            case ExpressionType.Parameter:                return this.VisitParameter((ParameterExpression)exp);            case ExpressionType.MemberAccess:                return this.VisitMemberAccess((MemberExpression)exp);            case ExpressionType.Call:                return this.VisitMethodCall((MethodCallExpression)exp);            case ExpressionType.Lambda:                return this.VisitLambda((LambdaExpression)exp);            case ExpressionType.New:                return this.VisitNew((NewExpression)exp);            case ExpressionType.NewArrayInit:            case ExpressionType.NewArrayBounds:                return this.VisitNewArray((NewArrayExpression)exp);            case ExpressionType.Invoke:                return this.VisitInvocation((InvocationExpression)exp);            case ExpressionType.MemberInit:                return this.VisitMemberInit((MemberInitExpression)exp);            case ExpressionType.ListInit:                return this.VisitListInit((ListInitExpression)exp);            default:                throw new Exception(string.Format("Unhandled expression type: '{0}'", exp.NodeType));        }    }    protected virtual MemberBinding VisitBinding(MemberBinding binding)    {        switch (binding.BindingType)        {            case MemberBindingType.Assignment:                return this.VisitMemberAssignment((MemberAssignment)binding);            case MemberBindingType.MemberBinding:                return this.VisitMemberMemberBinding((MemberMemberBinding)binding);            case MemberBindingType.ListBinding:                return this.VisitMemberListBinding((MemberListBinding)binding);            default:                throw new Exception(string.Format("Unhandled binding type '{0}'", binding.BindingType));        }    }    protected virtual ElementInit VisitElementInitializer(ElementInit initializer)    {        ReadOnlyCollection<Expression> arguments = this.VisitExpressionList(initializer.Arguments);        if (arguments != initializer.Arguments)        {            return Expression.ElementInit(initializer.AddMethod, arguments);        }        return initializer;    }    protected virtual Expression VisitUnary(UnaryExpression u)    {        Expression operand = this.Visit(u.Operand);        if (operand != u.Operand)        {            return Expression.MakeUnary(u.NodeType, operand, u.Type, u.Method);        }        return u;    }    protected virtual Expression VisitBinary(BinaryExpression b)    {        Expression left = this.Visit(b.Left);        Expression right = this.Visit(b.Right);        Expression conversion = this.Visit(b.Conversion);        if (left != b.Left || right != b.Right || conversion != b.Conversion)        {            if (b.NodeType == ExpressionType.Coalesce && b.Conversion != null)                return Expression.Coalesce(left, right, conversion as LambdaExpression);            else                return Expression.MakeBinary(b.NodeType, left, right, b.IsLiftedToNull, b.Method);        }        return b;    }    protected virtual Expression VisitTypeIs(TypeBinaryExpression b)    {        Expression expr = this.Visit(b.Expression);        if (expr != b.Expression)        {            return Expression.TypeIs(expr, b.TypeOperand);        }        return b;    }    protected virtual Expression VisitConstant(ConstantExpression c)    {        return c;    }    protected virtual Expression VisitConditional(ConditionalExpression c)    {        Expression test = this.Visit(c.Test);        Expression ifTrue = this.Visit(c.IfTrue);        Expression ifFalse = this.Visit(c.IfFalse);        if (test != c.Test || ifTrue != c.IfTrue || ifFalse != c.IfFalse)        {            return Expression.Condition(test, ifTrue, ifFalse);        }        return c;    }    protected virtual Expression VisitParameter(ParameterExpression p)    {        return p;    }    protected virtual Expression VisitMemberAccess(MemberExpression m)    {        Expression exp = this.Visit(m.Expression);        if (exp != m.Expression)        {            return Expression.MakeMemberAccess(exp, m.Member);        }        return m;    }    protected virtual Expression VisitMethodCall(MethodCallExpression m)    {        Expression obj = this.Visit(m.Object);        IEnumerable<Expression> args = this.VisitExpressionList(m.Arguments);        if (obj != m.Object || args != m.Arguments)        {            return Expression.Call(obj, m.Method, args);        }        return m;    }    protected virtual ReadOnlyCollection<Expression> VisitExpressionList(ReadOnlyCollection<Expression> original)    {        List<Expression> list = null;        for (int i = 0, n = original.Count; i < n; i++)        {            Expression p = this.Visit(original[i]);            if (list != null)            {                list.Add(p);            }            else if (p != original[i])            {                list = new List<Expression>(n);                for (int j = 0; j < i; j++)                {                    list.Add(original[j]);                }                list.Add(p);            }        }        if (list != null)        {            return list.AsReadOnly();        }        return original;    }    protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment assignment)    {        Expression e = this.Visit(assignment.Expression);        if (e != assignment.Expression)        {            return Expression.Bind(assignment.Member, e);        }        return assignment;    }    protected virtual MemberMemberBinding VisitMemberMemberBinding(MemberMemberBinding binding)    {        IEnumerable<MemberBinding> bindings = this.VisitBindingList(binding.Bindings);        if (bindings != binding.Bindings)        {            return Expression.MemberBind(binding.Member, bindings);        }        return binding;    }    protected virtual MemberListBinding VisitMemberListBinding(MemberListBinding binding)    {        IEnumerable<ElementInit> initializers = this.VisitElementInitializerList(binding.Initializers);        if (initializers != binding.Initializers)        {            return Expression.ListBind(binding.Member, initializers);        }        return binding;    }    protected virtual IEnumerable<MemberBinding> VisitBindingList(ReadOnlyCollection<MemberBinding> original)    {        List<MemberBinding> list = null;        for (int i = 0, n = original.Count; i < n; i++)        {            MemberBinding b = this.VisitBinding(original[i]);            if (list != null)            {                list.Add(b);            }            else if (b != original[i])            {                list = new List<MemberBinding>(n);                for (int j = 0; j < i; j++)                {                    list.Add(original[j]);                }                list.Add(b);            }        }        if (list != null)            return list;        return original;    }    protected virtual IEnumerable<ElementInit> VisitElementInitializerList(ReadOnlyCollection<ElementInit> original)    {        List<ElementInit> list = null;        for (int i = 0, n = original.Count; i < n; i++)        {            ElementInit init = this.VisitElementInitializer(original[i]);            if (list != null)            {                list.Add(init);            }            else if (init != original[i])            {                list = new List<ElementInit>(n);                for (int j = 0; j < i; j++)                {                    list.Add(original[j]);                }                list.Add(init);            }        }        if (list != null)            return list;        return original;    }    protected virtual Expression VisitLambda(LambdaExpression lambda)    {        Expression body = this.Visit(lambda.Body);        if (body != lambda.Body)        {            return Expression.Lambda(lambda.Type, body, lambda.Parameters);        }        return lambda;    }    protected virtual NewExpression VisitNew(NewExpression nex)    {        IEnumerable<Expression> args = this.VisitExpressionList(nex.Arguments);        if (args != nex.Arguments)        {            if (nex.Members != null)                return Expression.New(nex.Constructor, args, nex.Members);            else                return Expression.New(nex.Constructor, args);        }        return nex;    }    protected virtual Expression VisitMemberInit(MemberInitExpression init)    {        NewExpression n = this.VisitNew(init.NewExpression);        IEnumerable<MemberBinding> bindings = this.VisitBindingList(init.Bindings);        if (n != init.NewExpression || bindings != init.Bindings)        {            return Expression.MemberInit(n, bindings);        }        return init;    }    protected virtual Expression VisitListInit(ListInitExpression init)    {        NewExpression n = this.VisitNew(init.NewExpression);        IEnumerable<ElementInit> initializers = this.VisitElementInitializerList(init.Initializers);        if (n != init.NewExpression || initializers != init.Initializers)        {            return Expression.ListInit(n, initializers);        }        return init;    }    protected virtual Expression VisitNewArray(NewArrayExpression na)    {        IEnumerable<Expression> exprs = this.VisitExpressionList(na.Expressions);        if (exprs != na.Expressions)        {            if (na.NodeType == ExpressionType.NewArrayInit)            {                return Expression.NewArrayInit(na.Type.GetElementType(), exprs);            }            else            {                return Expression.NewArrayBounds(na.Type.GetElementType(), exprs);            }        }        return na;    }    protected virtual Expression VisitInvocation(InvocationExpression iv)    {        IEnumerable<Expression> args = this.VisitExpressionList(iv.Arguments);        Expression expr = this.Visit(iv.Expression);        if (args != iv.Arguments || expr != iv.Expression)        {            return Expression.Invoke(expr, args);        }        return iv;    }}

小结：最后一段代码还不能理解。表达式树是作为Linq的一部分。Linq知识一点都还不知道。♢♧♡♠