SqlHelper简单实现（通过Expression和反射）5.Lambda表达式解析类

这个ExpressionHelper类，是整个SqlHelper中，最核心的一个类，主要功能就是将Lambda表达式转换为Sql语句。同时这个转换过程比较复杂，所以下面详细讲解一下思路和这个类的作用。

0x01基本

在Sql语句中，主要由表名，字段，条件语句等元素组成，而这些元素中，表名，字段可以由实体表示出来，条件语句可以由Lambda表达式表现出来。

在Sql语句中，条件语句可以说是Select中的核心，其中很多功能和Lambda中提供的方法很相似，比如：

实体：

    [TableName("RA_MyBlog_Article")]
    public class ArticleEntity
    {
        [Primary]
        [Identity]
        //文章ID
        public int articleID { get; set; }
        //分类ID
        public int categoryID { get; set; }
        //文章标题
        public string articleTitle { get; set; }
        //文章版权
        public string articleCopyright { get; set; }
        //文章创建时间
        public DateTime articleDate { get; set; }
        //文章摘要
        public string articleAbstract { get; set; }
        //文章内容
        public string articleContain { get; set; }
        //文章所属User
        public int userID { get; set; }
    }

Lambda表达式	Sql表达式
GetList<ArticleEntity>(a=>a.articleID > 1 && a.userID = 1)	Select * From RA_MyBlog_Article Where articleID > 1 And userID = 1
GetList<ArticleEntity>(a=>list.Contains(a.articleID))	Select * From RA_MyBlog_Article Where articleID In [list中的元素]
Join<UserEntity,ArticleEntity>((a,b)=>a.UserID == b.UserID)	Select * From RA_MyBlog_Article,RA_MyBlog_User Join RA_MyBlog_User On (RA_MyBlog_Article.UserID = RA_MyBlog_User.UserID )

从上表可以看出，由Lambda表达式转换为Sql表达式是完全可能的。

0x02 Lambda表达式

Lambda设计到的内容比较多，大家有兴趣可以去百度找一下这方面的介绍，这里只介绍一些涉及到的部分：

以上面的表达式GetList<ArticleEntity>(a=>a.articleID > 1 && a.userID = 1)为例，其中a=>a.articleID > 1 && a.userID = 1这部分是我们需要的部分。在C#中，由Expression对象负责对Lambda表达式的解析和处理。Expression的子类有很多，分布在System.Linq.Expressions命名空间下，这里用到的有

UnaryExpression：一元表达式，比如取反'!'

ConstantExpression：常量表达式，比如1

MemberExpression：成员表达式，一般为变量，比如a.articleID

MethodCallExpression：函数表达式，比如Contains()

BinaryExpression：二元表达式，比如a.articleID > 1

对于这个例子：a.articleID > 1 && a.userID = 1，整体是一个与类型的二元表达式，左元素为a.articleID > 1，是一个Larger类型的二元表达式，其中左元素是成员表达式，右元素是常量表达式。右元素为a.userID = 1，是一个相等类型的二元表达式，其中左元素是成员表达式，右元素是常量表达式。

2.用到的枚举，没啥可说的，包含了Lambda表达式中常见的元素类型。

namespace RA.DataAccess.Enumerations
{
    public enum EnumNodeType
    {
        [Description("二元运算符")]
        BinaryOperator = 1,
        [Description("一元运算符")]
        UndryOperator = 2,
        [Description("常量表达式")]
        Constant = 3,
        [Description("成员（变量）")]
        MemberAccess = 4,
        [Description("函数")]
        Call = 5,
        [Description("未知")]
        Unknown = -99,
        [Description("不支持")]
        NotSupported = -98
    }
}

0x03 功能部分

1.判断表达式类型

        /// <summary>
        /// 判断表达式类型
        /// </summary>
        /// <param name="func">lambda表达式</param>
        /// <returns></returns>
        private static EnumNodeType CheckExpressionType(Expression func)
        {
            switch (func.NodeType)
            {
                case ExpressionType.AndAlso:
                case ExpressionType.OrElse:
                case ExpressionType.Equal:
                case ExpressionType.GreaterThanOrEqual:
                case ExpressionType.LessThanOrEqual:
                case ExpressionType.GreaterThan:
                case ExpressionType.LessThan:
                case ExpressionType.NotEqual:
                    return EnumNodeType.BinaryOperator;
                case ExpressionType.Constant:
                    return EnumNodeType.Constant;
                case ExpressionType.MemberAccess:
                    return EnumNodeType.MemberAccess;
                case ExpressionType.Call:
                    return EnumNodeType.Call;
                case ExpressionType.Not:
                case ExpressionType.Convert:
                    return EnumNodeType.UndryOperator;
                default:
                    return EnumNodeType.Unknown;
            }
        }

2.判断一元表达式：

        /// <summary>
        /// 判断一元表达式
        /// </summary>
        /// <param name="func"></param>
        /// <returns></returns>
        private static string VisitUnaryExpression(UnaryExpression func)
        {
            var result = ExpressionTypeToString(func.NodeType);
            var funcType = CheckExpressionType(func.Operand);
            switch (funcType)
            {
                case EnumNodeType.BinaryOperator:
                    return result + VisitBinaryExpression(func.Operand as BinaryExpression);
                case EnumNodeType.Constant:
                    return result + VisitConstantExpression(func.Operand as ConstantExpression);
                case EnumNodeType.Call:
                    return result + VisitMethodCallExpression(func.Operand as MethodCallExpression);
                case EnumNodeType.UndryOperator:
                    return result + VisitUnaryExpression(func.Operand as UnaryExpression);
                case EnumNodeType.MemberAccess:
                    return result + VisitMemberAccessExpression(func.Operand as MemberExpression);
                default:
                    throw new NotSupportedException("不支持的操作在一元操作处理中：" + funcType.GetDescription());
            }
        }

3.判断常量表达式：

        /// <summary>
        /// 判断常量表达式
        /// </summary>
        /// <param name="func"></param>
        /// <returns></returns>
        private static string VisitConstantExpression(ConstantExpression func)
        {
            if (func.Value.ToString() == "")
            {
                return "\'\' ";
            }
            else if (func.Value.ToString() == "True")
            {
                return "1 = 1 ";
            }
            else if (func.Value.ToString() == "False")
            {
                return "0 = 1 ";
            }
            else
            {
                return "'" + func.Value.ToString() + "' ";
                
            }
        }

4.判断变量表达式

        /// <summary>
        /// 判断包含变量的表达式
        /// </summary>
        /// <param name="func"></param>
        /// <returns></returns>
        private static string VisitMemberAccessExpression(MemberExpression func)
        {
            try
            {
                var tablename = EntityHelper.GetTableName(func.Expression.Type);
                return tablename + "." + func.Member.Name + " ";
            }catch
            {
                object value;
                switch (func.Type.Name)
                {
                    case "Int32":
                    {
                        var getter = Expression.Lambda<Func<int>>(func).Compile();
                        value = getter();
                    }
                        break;
                    case "String":
                    {
                        var getter = Expression.Lambda<Func<string>>(func).Compile();
                        value = "'" + getter() + "'";
                    }
                        break;
                    case "DateTime":
                    {
                        var getter = Expression.Lambda<Func<DateTime>>(func).Compile();
                        value = "'" + getter() + "'";
                    }
                        break;
                    default:
                    {
                        var getter = Expression.Lambda<Func<object>>(func).Compile();
                        value = getter();
                    }
                        break;
                }
                return value.ToString();
            }
        }

5.判断函数表达式：为了演示，此处这个表达式只支持Contains()函数，其他的函数可以按需添加。

        /// <summary>
        /// 判断包含函数的表达式
        /// </summary>
        /// <param name="func"></param>
        /// <returns></returns>
        private static String VisitMethodCallExpression(MethodCallExpression func)
        {
            if (func.Method.Name.Contains("Contains"))
            {
                //获得调用者的内容元素
                var getter = Expression.Lambda<Func<object>>(func.Object).Compile();
                var data = getter() as IEnumerable;
                //获得字段
                var caller = func.Arguments[0];
                while (caller.NodeType == ExpressionType.Call)
                {
                    caller = (caller as MethodCallExpression).Object;
                }
                var field = VisitMemberAccessExpression(caller as MemberExpression);
                var list = (from object i in data select "'" + i + "'").ToList();
                return field + " IN (" + string.Join(",", list.Cast<string>().ToArray()) + ") ";
            }
            else
            {
                throw new NotSupportedException("不支持的函数操作:" + func.Method.Name);
            }
        }

6.判断二元表达式：二元表达式一般由其他表达式组成，有时还会有嵌套的情况，所以此处使用递归来解析。

        /// <summary> 
        /// 判断包含二元运算符的表达式
        /// </summary>
        /// <remarks>注意，这个函数使用了递归，修改时注意不要修改了代码顺序和逻辑</remarks>
        /// <param name="func"></param>
        private static string VisitBinaryExpression(BinaryExpression func)
        {
            var result = "(";
            var leftType = CheckExpressionType(func.Left);
            switch (leftType)
            {
                case EnumNodeType.BinaryOperator:
                    result += VisitBinaryExpression(func.Left as BinaryExpression);break;
                case EnumNodeType.Constant:
                    result += VisitConstantExpression(func.Left as ConstantExpression);break;
                case EnumNodeType.MemberAccess:
                    result += VisitMemberAccessExpression(func.Left as MemberExpression);break;
                case EnumNodeType.UndryOperator:
                    result += VisitUnaryExpression(func.Left as UnaryExpression);break;
                case EnumNodeType.Call:
                    result += VisitMethodCallExpression(func.Left as MethodCallExpression);break;
                default:
                    throw new NotSupportedException("不支持的操作在二元操作处理中：" + leftType.GetDescription());
            }

            result += ExpressionTypeToString(func.NodeType) + " ";

            var rightType = CheckExpressionType(func.Right);
            switch (rightType)
            {
                case EnumNodeType.BinaryOperator:
                    result += VisitBinaryExpression(func.Right as BinaryExpression); break;
                case EnumNodeType.Constant:
                    result += VisitConstantExpression(func.Right as ConstantExpression); break;
                case EnumNodeType.MemberAccess:
                    result += VisitMemberAccessExpression(func.Right as MemberExpression); break;
                case EnumNodeType.UndryOperator:
                    result += VisitUnaryExpression(func.Right as UnaryExpression); break;
                case EnumNodeType.Call:
                    result += VisitMethodCallExpression(func.Right as MethodCallExpression); break;
                default:
                    throw new NotSupportedException("不支持的操作在二元操作处理中：" + rightType.GetDescription());
            }

            result += ") ";
            return result;
        }

7.将Lambda表达式转换为Sql语句。整个类的入口点：

        /// <summary>
        /// 通过Lambda解析为Sql
        /// </summary>
        /// <param name="func"></param>
        /// <returns></returns>
        public static string GetSqlByExpression(Expression func)
        {
            var funcType = CheckExpressionType(func);
            switch (funcType)
            {
                case EnumNodeType.BinaryOperator:
                    return FormatSqlExpression(VisitBinaryExpression(func as BinaryExpression));
                case EnumNodeType.Constant:
                    return FormatSqlExpression(VisitConstantExpression(func as ConstantExpression));
                case EnumNodeType.Call:
                    return FormatSqlExpression(VisitMethodCallExpression(func as MethodCallExpression));
                case EnumNodeType.UndryOperator:
                    return FormatSqlExpression(VisitUnaryExpression(func as UnaryExpression));
                case EnumNodeType.MemberAccess:
                    return FormatSqlExpression(VisitMemberAccessExpression(func as MemberExpression));
                default:
                    throw new NotSupportedException("不支持的操作在表达式处理中：" + funcType.GetDescription());
            }
        }