Linq系列(5)——表达式树之案例应用

　在进入今天的正题之前，先感慨下本人的blog的人气一篇不如一篇。再加上换公司后人身自由受到了比之前大得多得多的限制，实在令本人有些郁闷。不过每次提笔写些东西跟大家分享，总是能让我感到愉悦和欣慰，希望我的文章和理解能帮助到大家。前段时间周星星给我聊天的时候跟我说我写的东西msdn上都能查到，希望我能多写写自己的思考。其实是这样的，就知识查询手册这个层面来说，我相信.net的知识msdn上没有查不到的，我只是努力给大家展现我自己的一个理解和学习的过程，把一些知识以一个特定的逻辑顺序串联起来，希望通过我的一些带有个人色彩的陈述和表达使大家能理解和运用这些知识。

      好了，进入正题，上一篇已经说过了，这一篇会写一些轻松的东西，主要来写写表达式树的一些案例和应用，相对而言会比较简单。

     我之前已经写过，方法可以做什么表达式树就可以做什么。我们先来看一个例子。

     有一个Aircraft的类

    

 public class Aircraft
    {
        public int[] AircraftNumber
        {
            get;
            set;
        }

        public string AirlineId
        {
            get;
            set;
        }

        public Aircraft()
        { 
        }

        public bool Test()
        {
            return true;
        }
    }

首先 我们来看一个函数,这个函数的作用就是判断Aircraft中的AirlineId是否为null,我们先来看看用lambda表达式怎么写

 Func<Aircraft, bool> methodEqualNull = item => item.AirlineId == null;

好，现在问题来了。如果我们需要在运行时来构建这个逻辑怎么办，具体一点，比如我们需要把这个AirlineId当成参数传进来，就是运行时判断哪个属性是否为null怎么办，然后甚至null也是运行时动态传进来的怎么办，即，我们需要运行时判断某个属性是否等于某个具体常量，怎么办。

这个时候我们就可以用表达式树了。

 ParameterExpression aircraftParameter = Expression.Parameter(typeof(Aircraft), "aircraftTestString");
 MemberExpression memberAirlineIdExpression = Expression.Property(aircraftParameter, "AirlineId");
 ConstantExpression nullConstant = Expression.Constant(null);
  Expression<Func<Aircraft, bool>> equalNull = Expression.Lambda<Func<Aircraft, bool>>
                                                                         (Expression.Equal  (memberAirlineIdExp ression, nullConstant),
                                                                          new ParameterExpression[] { aircraftParameter }
                                                                          );

我们先来普及下表达式树中几个常用的类：

 ParameterExpression：参数表达式，用于表示表达式树中需要用到的参数

 MemberExpression：成员表达式，用于表示某个ParameterExpression中的某个成员

好，知道了这2个概念，我们就来分析下这2句话:

 ParameterExpression aircraftParameter = Expression.Parameter(typeof(Aircraft), "aircraftTestString");

这一句表示表达式树中有一个参数，它的类型是Aircraft，
 MemberExpression memberAirlineIdExpression = Expression.Property(aircraftParameter, "AirlineId");

这一句表示有一个memberAirlineIdExpression ，这个变量用来表示Aircraft这个类型中的AirlineId这个属性

ConstantExpression：这个简单，就是常量表达式

Expression.Lambda<Func<Aircraft, bool>>
                                                                         (Expression.Equal(memberAirlineIdExpression, nullConstant),
                                                                          new ParameterExpression[] { aircraftParameter }
                                                                          );

这句代码很重要，我们具体分析下，首先它表示构建一个参数为Aircraft，返回类型为bool的表达式树，

new ParameterExpression[] { aircraftParameter }，这句话表示这个表达式树的参数为aircraftParameter ，

Expression.Equal(memberAirlineIdExpression, nullConstant)这句话表示这个表达式的逻辑是判断memberAirlineIdExpression和nullConstant是否相等。

好了，有了上面的例子，我们再来看一个类似的表达式树，它要构建出item => item.AirlineId == string.Empty这个逻辑

 ConstantExpression emptyConstant = Expression.Constant(string.Empty);
Expression<Func<Aircraft, bool>> equalEmpty = Expression.Lambda<Func<Aircraft, bool>>
                                                                          (
                                                                            Expression.Equal(memberAirlineIdExpression, emptyConstant),
                                                                            new ParameterExpression[] { aircraftParameter }
                                                                          );
            

好了，通过上面两个例子，我们可以看出，如果运用表达式树，ParameterExpression，MemberExpression，都可以在运行时当成参数传入，也都可以在运行时动态构建，甚至如果大家自己尝试，大家可以发现，Expression.Equal这个很核心的逻辑，我们都可以通过传入一个字符串，然后调用Expression.Call方法来构建，但我在此不推荐这么做，因为字符串没有编译时的检查，很不完全，就算是一个没有对应具体方法的字符串也可以被传入。

然后，已经构建好的表达式树也可以被其他的表达式树调用，我们再来看个例子

       Expression<Func<Aircraft, bool>> expressionString = Expression.Lambda<Func<Aircraft, bool>>
                                                                           (
                                                                             Expression.Or(equalNull.Body, equalEmpty.Body),
                                                                             new ParameterExpression[] { aircraftParameter }
                                                                           );

这段代码就是运用之前的2个表达式树，构建了一个string.IsNullOrEmpty的逻辑。

顺带说一下，Body和Parameter是表达式树中2个很核心的概念，我会在下一篇博文中具体来说。

好，我曾经说过，方法可以做的事情表达式树都可以做，因为实际上方法可以按照表达式树的形式来进行保存。

大家可以参考下这篇文章http://rednaxelafx.javaeye.com/blog/247270

我作一些摘抄

算术表达式部分：

static void Add( ) {  

    // Expression<Func<int, int, int>> add = ( x, y ) => x + y;  

    ParameterExpression x = Expression.Parameter( typeof( int ), "x" );  

    ParameterExpression y = Expression.Parameter( typeof( int ), "y" );  

    Expression<Func<int, int, int>> add = Expression.Lambda<Func<int, int, int>>(  

        Expression.Add(  

            x, // left  

            y // right  

        ),  

        new ParameterExpression[ ] { x, y }  

    );  

}  

按位运算表达式

// "<<" operator  

static void LeftShift( ) {  

    // Expression<Func<int, int, int>> lshift = ( x, y ) => x << y;  

    ParameterExpression x = Expression.Parameter( typeof( int ), "x" );  

    ParameterExpression y = Expression.Parameter( typeof( int ), "y" );  

    Expression<Func<int, int, int>> lshift = Expression.Lambda<Func<int, int, int>>(  

        Expression.LeftShift(  

            x, // left  

            y // right  

        ),  

        new ParameterExpression[ ] { x, y }  

    );  

}  

条件表达式

// "? :" operator  

static void Condition( ) {  

    // Expression<Func<bool, int, int, int>> cond = ( c, x, y ) => c ? x : y;  

    ParameterExpression c = Expression.Parameter( typeof( bool ), "c" );  

    ParameterExpression x = Expression.Parameter( typeof( int ), "x" );  

    ParameterExpression y = Expression.Parameter( typeof( int ), "y" );  

    Expression<Func<bool, int, int, int>> cond = Expression.Lambda<Func<bool, int, int, int>>(  

        Expression.Condition(  

            c, // test  

            x, // if true  

            y // if false  

        ),  

        new ParameterExpression[ ] { c, x, y }  

    );  

} 

等于大于小于等比较大小的部分

static void GreaterThan( ) {  

    // Expression<Func<int, int, bool>> gt = ( x, y ) => x > y;  

    ParameterExpression x = Expression.Parameter( typeof( int ), "x" );  

    ParameterExpression y = Expression.Parameter( typeof( int ), "y" );  

    Expression<Func<int, int, bool>> gt = Expression.Lambda<Func<int, int, bool>>(  

        Expression.GreaterThan(  

            x, // left  

            y // right  

        ),  

        new ParameterExpression[ ] { x, y }  

    );  

}  

关系表达式

static void AndAlso( ) {  

    // Note that And() is for bitwise and, and AndAlso() is for logical and.  

    // Note also that the shortcut semantics is implemented with AndAlso().  

    // Expression<Func<bool, bool, bool>> and = ( x, y ) => x && y;  

    ParameterExpression x = Expression.Parameter( typeof( bool ), "x" );  

    ParameterExpression y = Expression.Parameter( typeof( bool ), "y" );  

    Expression<Func<bool, bool, bool>> and = Expression.Lambda<Func<bool, bool, bool>>(  

        Expression.AndAlso(  

            x, // left  

            y // right  

        ),  

        new ParameterExpression[ ] { x, y }  

    );  

}  

类型转换表达式

 // C-style conversion  

static void Convert( ) {  

    // Expression<Func<int, short>> conv = x => ( short ) x;  

    ParameterExpression x = Expression.Parameter( typeof( int ), "x" );  

    Expression<Func<int, short>> conv = Expression.Lambda<Func<int, short>>(  

        Expression.Convert(  

            x,              // expression  

            typeof( short ) // type  

        ),  

        new ParameterExpression[ ] { x }  

    );  

}  

成员表达式

 // C-style conversion  

static void Convert( ) {  

    // Expression<Func<int, short>> conv = x => ( short ) x;  

    ParameterExpression x = Expression.Parameter( typeof( int ), "x" );  

    Expression<Func<int, short>> conv = Expression.Lambda<Func<int, short>>(  

        Expression.Convert(  

            x,              // expression  

            typeof( short ) // type  

        ),  

        new ParameterExpression[ ] { x }  

    );  

}  

数组表达式

static void ArrayIndex( ) {  

    // Expression<Func<int[ ], int, int>> aryIdx = ( a, i ) => a[ i ];  

    ParameterExpression a = Expression.Parameter( typeof( int[ ] ), "a" );  

    ParameterExpression i = Expression.Parameter( typeof( int ), "i" );  

    Expression<Func<int[ ], int, int>> aryIdx = Expression.Lambda<Func<int[ ], int, int>>(  

        Expression.ArrayIndex(  

            a, // array  

            i // index  

        ),  

        new ParameterExpression[ ] { a, i }  

    );  

}  

方法/委托调用表达式

// Calling a static method  

static void Call( ) {  

    // Note that to call a static method, use Expression.Call(),  

    // and set "instance" to null  

    // Expression<Func<string, int>> scall = s => int.Parse( s );  

    ParameterExpression s = Expression.Parameter( typeof( string ), "s" );  

    Expression<Func<string, int>> scall = Expression.Lambda<Func<string, int>>(  

        Expression.Call(  

            null,                      // instance  

            typeof( int ).GetMethod(   // method  

                "Parse", new Type[ ] { typeof( string ) } ),  

            new Expression[ ] { s }    // arguments  

        ),  

        new ParameterExpression[ ] { s }  

    );  

}     

 https://www.cnblogs.com/FlyEdward/archive/2010/04/15/Linq_ExpressionTree5.html