解析表达式

.net中的条件查询需要支持表达式有两个理由：

1 更为灵活，也更为直观；

2 结合c#的强类型检查，代码可靠性可以得到增强。

要在条件查询中支持表达式，有几个要求要能得到满足：

1 能支持多表联合查询；

2 子类能自动关联父类；

3 对表达式的支持要尽可能的少限制；

4 不能要求一次性输入所有的表达式，而是要能根据条件逐步的拼入表达式。

在条件查询中支持表达式，说起来好像很玄奥，但仔细想下，不就是将表达式转换为sql语句吗？所以，最简单的考虑，就是解析表达式，然后来构造sql语句的from和where字句而已。

而from字句比较简单，其实就是识别表达式中用的类，没有用过的类，就添加表名列表中，最后在构造时按顺序逐一添加到from字句即可，当然，需要为其按序号分配一个别名。

所以核心的工作就是解析表达式来构造where字句。

首先就是表达式的解析：

        private string Visit(Expression exp)
        {
            if (exp != null)
                switch (exp.NodeType)
                {
                    case ExpressionType.Negate:
                    case ExpressionType.NegateChecked:
                    case ExpressionType.Not:
                    case ExpressionType.Convert:
                    case ExpressionType.ConvertChecked:
                        return 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:
                        return VisitBinary((BinaryExpression)exp);
                    case ExpressionType.Constant:
                        return VisitConstant((ConstantExpression)exp);
                    case ExpressionType.Parameter:
                        return VisitParameter((ParameterExpression)exp);
                    case ExpressionType.MemberAccess:
                        return VisitMemberAccess((MemberExpression)exp);
                    case ExpressionType.Call:
                        return this.VisitMethodCall((MethodCallExpression)exp);
                    default:
                        throw new Exception(string.Format("Unhandled expression type: '{0}'", exp.NodeType));
                }
            return null;
        }

一元表达式和两元表达式的实现都是将表达式类型转换为一个操作，然后将该操作和进一步的解析出的表达式拼接到一起，如一元表达式的解析是：

        private string VisitUnary(UnaryExpression u)
        {
            if (u == null) return null;
            string rs = null;
            string op = null;
            switch (u.NodeType)
            {
                case ExpressionType.Negate:
                case ExpressionType.NegateChecked:
                    op = "-";
                    break;
                case ExpressionType.Not:
                    op = "Not ";
                    break;
                case ExpressionType.Convert:
                case ExpressionType.ConvertChecked:
                    return Visit(u.Operand);
            }
            rs = String.Format("({0}{1})", op, Visit(u.Operand));
            return rs;
        }

常量的解析首先看能否常量的类型是否能直接转换，如果不能则将该表达式动态执行取其结果：

        private string VisitConstant(ConstantExpression c)
        {
            if (c == null) return null;
            string rs = Common.TransObjToSqlValue(c.Value);
            if (rs == null && !Common.CanTrans(c.Value))
            {
                LambdaExpression lambda = Expression.Lambda(c);
                Delegate fn = lambda.Compile();
                var obj = fn.DynamicInvoke(null);
                rs = Common.TransObjToSqlValue(obj);
            }
            return rs;
        }

参数的解析稍微复杂点，主要需要判断该参数是否是给的类的父类/祖类中的成员，如果是还需要判断该父类/祖类是否已经被添加到所有数据表中了，如果没有需要将其引用过来并和该子类自动进行关联。

成员引用的解析主要是将成员首先判断是否是参数，如果是那么则按参数进行解析，否则还是要视为一个动态的表达式，执行后取其值。

方法调用的解析最为复杂，因为，方法可以有多个参数、参数还有可能需要进一步的解析，后来考虑到为了进行查询而构造的表达式，其调用的方法应该不会如此复杂，所以对方法调用所支持的表达式进行了限制，如参数只能由一个，且为简单数值等等：

       private string VisitMethodCall(MethodCallExpression c)
        {
            if (c == null) return null;
            string rs = null;
            if (c.Object != null)
            {
                //实例对象的方法调用，没有参数调用
                if (c.Object.NodeType == ExpressionType.Constant)
                {
                    //实例对象是常量
                    LambdaExpression lambda = Expression.Lambda(c);
                    Delegate fn = lambda.Compile();
                    rs = Common.TransObjToSqlValue(fn.DynamicInvoke(null));
                }
                else if (c.Object.NodeType == ExpressionType.MemberAccess)
                {
                    LambdaExpression lambda = Expression.Lambda(c.Object);
                    Delegate fn = lambda.Compile();
                    var obj = fn.DynamicInvoke(null);
                    ParameterExpression paramObj = Expression.Parameter(typeof(object), "entity");
                    var paramEntityObj = Expression.Convert(paramObj, c.Object.Type);


                    var exp = Expression.Call(paramEntityObj, c.Method);
                    var l = Expression.Lambda<Func<object, object>>(exp, paramObj);
                    Func<object, object> d = l.Compile();
                    var o = d(obj);
                    rs = Common.TransObjToSqlValue(o);
                }
            }
            else
            {
                //静态方法调用，只有一个参数
                LambdaExpression lambda = Expression.Lambda(c.Arguments[0]);
                Delegate fn = lambda.Compile();
                var obj = fn.DynamicInvoke(null);
                var o = c.Method.Invoke(null, new object[] { obj });
                rs = Common.TransObjToSqlValue(o);
            }
            return rs;
        }

有了表达式的解析，我们就可以定义创建函数和按条件添加表达式的函数了：

        public static ExpressionVisitor_Sql Create<T>(Expression<Func<T, bool>> predicate)
        {
            var ev = new ExpressionVisitor_Sql();
            var ty = typeof(T);
            ev.m_TableList.Add(ty.Name, 1);
            if (predicate != null)
                ev.m_SqlWhere = " Where " + ev.Visit(predicate.Body);
            return ev;
        }

以及：

        public void Append<T1, T2>(bool AppendIf, Expression<Func<T1, T2, bool>> predicate)
        {
            var ty = typeof(T1);
            if (AppendIf && m_TableList.InList(ty.Name) && predicate != null)
            {
                int count = m_TableList.Count + m_TableList2.Count;
                ty = typeof(T2);
                if (m_TableList.InList(ty.Name))
                    m_TableList2.Add(ty.Name, count + 1);
                else
                    m_TableList.Add(ty.Name, count + 1);
                if (m_SqlWhere == null)
                    m_SqlWhere = " Where " + Visit(predicate.Body);
                else
                    m_SqlWhere += " And " + Visit(predicate.Body);
            }
        }

当然还可以定义支持更多泛型参数表达式的类似函数。

这里面有一个比较特殊的地方，就是字符串和其它类型有一个不同点在于，字符串有一个包含操作，而包含操作不像大于、等于之类的比较操作在表达式中有明确的对应关系可供解析，所以最后用一个单独的Append_Like函数进行单独的解析。

目前还存在一个问题难以解决，即如果需要反复用到某个类，由于表达式中无法确定到底是指的哪一个类，所以没法使用重名的类进行关联查询。