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

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

0x01基本

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

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

实体：

 1     [TableName("RA_MyBlog_Article")]
 2     public class ArticleEntity
 3     {
 4         [Primary]
 5         [Identity]
 6         //文章ID
 7         public int articleID { get; set; }
 8         //分类ID
 9         public int categoryID { get; set; }
10         //文章标题
11         public string articleTitle { get; set; }
12         //文章版权
13         public string articleCopyright { get; set; }
14         //文章创建时间
15         public DateTime articleDate { get; set; }
16         //文章摘要
17         public string articleAbstract { get; set; }
18         //文章内容
19         public string articleContain { get; set; }
20         //文章所属User
21         public int userID { get; set; }
22     }

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表达式中常见的元素类型。

 1 namespace RA.DataAccess.Enumerations
 2 {
 3     public enum EnumNodeType
 4     {
 5         [Description("二元运算符")]
 6         BinaryOperator = 1,
 7         [Description("一元运算符")]
 8         UndryOperator = 2,
 9         [Description("常量表达式")]
10         Constant = 3,
11         [Description("成员（变量）")]
12         MemberAccess = 4,
13         [Description("函数")]
14         Call = 5,
15         [Description("未知")]
16         Unknown = -99,
17         [Description("不支持")]
18         NotSupported = -98
19     }
20 }

0x03 功能部分

1.判断表达式类型

 1         /// <summary>
 2         /// 判断表达式类型
 3         /// </summary>
 4         /// <param name="func">lambda表达式</param>
 5         /// <returns></returns>
 6         private static EnumNodeType CheckExpressionType(Expression func)
 7         {
 8             switch (func.NodeType)
 9             {
10                 case ExpressionType.AndAlso:
11                 case ExpressionType.OrElse:
12                 case ExpressionType.Equal:
13                 case ExpressionType.GreaterThanOrEqual:
14                 case ExpressionType.LessThanOrEqual:
15                 case ExpressionType.GreaterThan:
16                 case ExpressionType.LessThan:
17                 case ExpressionType.NotEqual:
18                     return EnumNodeType.BinaryOperator;
19                 case ExpressionType.Constant:
20                     return EnumNodeType.Constant;
21                 case ExpressionType.MemberAccess:
22                     return EnumNodeType.MemberAccess;
23                 case ExpressionType.Call:
24                     return EnumNodeType.Call;
25                 case ExpressionType.Not:
26                 case ExpressionType.Convert:
27                     return EnumNodeType.UndryOperator;
28                 default:
29                     return EnumNodeType.Unknown;
30             }
31         }

2.判断一元表达式：

 1         /// <summary>
 2         /// 判断一元表达式
 3         /// </summary>
 4         /// <param name="func"></param>
 5         /// <returns></returns>
 6         private static string VisitUnaryExpression(UnaryExpression func)
 7         {
 8             var result = ExpressionTypeToString(func.NodeType);
 9             var funcType = CheckExpressionType(func.Operand);
10             switch (funcType)
11             {
12                 case EnumNodeType.BinaryOperator:
13                     return result + VisitBinaryExpression(func.Operand as BinaryExpression);
14                 case EnumNodeType.Constant:
15                     return result + VisitConstantExpression(func.Operand as ConstantExpression);
16                 case EnumNodeType.Call:
17                     return result + VisitMethodCallExpression(func.Operand as MethodCallExpression);
18                 case EnumNodeType.UndryOperator:
19                     return result + VisitUnaryExpression(func.Operand as UnaryExpression);
20                 case EnumNodeType.MemberAccess:
21                     return result + VisitMemberAccessExpression(func.Operand as MemberExpression);
22                 default:
23                     throw new NotSupportedException("不支持的操作在一元操作处理中：" + funcType.GetDescription());
24             }
25         }

3.判断常量表达式：

 1         /// <summary>
 2         /// 判断常量表达式
 3         /// </summary>
 4         /// <param name="func"></param>
 5         /// <returns></returns>
 6         private static string VisitConstantExpression(ConstantExpression func)
 7         {
 8             if (func.Value.ToString() == "")
 9             {
10                 return "\'\' ";
11             }
12             else if (func.Value.ToString() == "True")
13             {
14                 return "1 = 1 ";
15             }
16             else if (func.Value.ToString() == "False")
17             {
18                 return "0 = 1 ";
19             }
20             else
21             {
22                 return "'" + func.Value.ToString() + "' ";
23                 
24             }
25         }

4.判断变量表达式

 1         /// <summary>
 2         /// 判断包含变量的表达式
 3         /// </summary>
 4         /// <param name="func"></param>
 5         /// <returns></returns>
 6         private static string VisitMemberAccessExpression(MemberExpression func)
 7         {
 8             try
 9             {
10                 var tablename = EntityHelper.GetTableName(func.Expression.Type);
11                 return tablename + "." + func.Member.Name + " ";
12             }catch
13             {
14                 object value;
15                 switch (func.Type.Name)
16                 {
17                     case "Int32":
18                     {
19                         var getter = Expression.Lambda<Func<int>>(func).Compile();
20                         value = getter();
21                     }
22                         break;
23                     case "String":
24                     {
25                         var getter = Expression.Lambda<Func<string>>(func).Compile();
26                         value = "'" + getter() + "'";
27                     }
28                         break;
29                     case "DateTime":
30                     {
31                         var getter = Expression.Lambda<Func<DateTime>>(func).Compile();
32                         value = "'" + getter() + "'";
33                     }
34                         break;
35                     default:
36                     {
37                         var getter = Expression.Lambda<Func<object>>(func).Compile();
38                         value = getter();
39                     }
40                         break;
41                 }
42                 return value.ToString();
43             }
44         }

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

 1         /// <summary>
 2         /// 判断包含函数的表达式
 3         /// </summary>
 4         /// <param name="func"></param>
 5         /// <returns></returns>
 6         private static String VisitMethodCallExpression(MethodCallExpression func)
 7         {
 8             if (func.Method.Name.Contains("Contains"))
 9             {
10                 //获得调用者的内容元素
11                 var getter = Expression.Lambda<Func<object>>(func.Object).Compile();
12                 var data = getter() as IEnumerable;
13                 //获得字段
14                 var caller = func.Arguments[0];
15                 while (caller.NodeType == ExpressionType.Call)
16                 {
17                     caller = (caller as MethodCallExpression).Object;
18                 }
19                 var field = VisitMemberAccessExpression(caller as MemberExpression);
20                 var list = (from object i in data select "'" + i + "'").ToList();
21                 return field + " IN (" + string.Join(",", list.Cast<string>().ToArray()) + ") ";
22             }
23             else
24             {
25                 throw new NotSupportedException("不支持的函数操作:" + func.Method.Name);
26             }
27         }

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

 1         /// <summary> 
 2         /// 判断包含二元运算符的表达式
 3         /// </summary>
 4         /// <remarks>注意，这个函数使用了递归，修改时注意不要修改了代码顺序和逻辑</remarks>
 5         /// <param name="func"></param>
 6         private static string VisitBinaryExpression(BinaryExpression func)
 7         {
 8             var result = "(";
 9             var leftType = CheckExpressionType(func.Left);
10             switch (leftType)
11             {
12                 case EnumNodeType.BinaryOperator:
13                     result += VisitBinaryExpression(func.Left as BinaryExpression);break;
14                 case EnumNodeType.Constant:
15                     result += VisitConstantExpression(func.Left as ConstantExpression);break;
16                 case EnumNodeType.MemberAccess:
17                     result += VisitMemberAccessExpression(func.Left as MemberExpression);break;
18                 case EnumNodeType.UndryOperator:
19                     result += VisitUnaryExpression(func.Left as UnaryExpression);break;
20                 case EnumNodeType.Call:
21                     result += VisitMethodCallExpression(func.Left as MethodCallExpression);break;
22                 default:
23                     throw new NotSupportedException("不支持的操作在二元操作处理中：" + leftType.GetDescription());
24             }
25 
26             result += ExpressionTypeToString(func.NodeType) + " ";
27 
28             var rightType = CheckExpressionType(func.Right);
29             switch (rightType)
30             {
31                 case EnumNodeType.BinaryOperator:
32                     result += VisitBinaryExpression(func.Right as BinaryExpression); break;
33                 case EnumNodeType.Constant:
34                     result += VisitConstantExpression(func.Right as ConstantExpression); break;
35                 case EnumNodeType.MemberAccess:
36                     result += VisitMemberAccessExpression(func.Right as MemberExpression); break;
37                 case EnumNodeType.UndryOperator:
38                     result += VisitUnaryExpression(func.Right as UnaryExpression); break;
39                 case EnumNodeType.Call:
40                     result += VisitMethodCallExpression(func.Right as MethodCallExpression); break;
41                 default:
42                     throw new NotSupportedException("不支持的操作在二元操作处理中：" + rightType.GetDescription());
43             }
44 
45             result += ") ";
46             return result;
47         }

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

 1         /// <summary>
 2         /// 通过Lambda解析为Sql
 3         /// </summary>
 4         /// <param name="func"></param>
 5         /// <returns></returns>
 6         public static string GetSqlByExpression(Expression func)
 7         {
 8             var funcType = CheckExpressionType(func);
 9             switch (funcType)
10             {
11                 case EnumNodeType.BinaryOperator:
12                     return FormatSqlExpression(VisitBinaryExpression(func as BinaryExpression));
13                 case EnumNodeType.Constant:
14                     return FormatSqlExpression(VisitConstantExpression(func as ConstantExpression));
15                 case EnumNodeType.Call:
16                     return FormatSqlExpression(VisitMethodCallExpression(func as MethodCallExpression));
17                 case EnumNodeType.UndryOperator:
18                     return FormatSqlExpression(VisitUnaryExpression(func as UnaryExpression));
19                 case EnumNodeType.MemberAccess:
20                     return FormatSqlExpression(VisitMemberAccessExpression(func as MemberExpression));
21                 default:
22                     throw new NotSupportedException("不支持的操作在表达式处理中：" + funcType.GetDescription());
23             }
24         }