自己动手写ORM（02）：Sql生成器实现

上一节中鄙人通过解析表达式树生成Sql碎片，其中我也把解析表达式类代码贴了出来，文章发布之后我对ExpressionAnalyzer类做了些改动，下面我还会将代码贴出来，废话不多说，直接进入今天的主题。

实体类设计：

　　首先，我觉得要想直接通过实体类生成Sql语句，那么你可能要知道这个实体类对应数据库表中的主键和外键是什么，在此我加入了两个特性来标识主键和外键关系。如下

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

/// <summary>     /// 外键表特性（导航属性）     /// </summary>     public class GuidanceAttribute : System.Attribute     {         /// <summary>         /// 依赖字段         /// </summary>         public string DepandField { get; set; }     }    public class MessageAttribute : System.Attribute     {         /// <summary>         /// 链接字符串名         /// </summary>         public string ConStr { get; set; }     }  public class PrimaryKeyAttribute : System.Attribute     {       }

　　实体类如下：

 1 using LC.Model;
 2 using LC.Model.Attribute;
 3 using System;
 4 using System.Collections.Generic;
 5 using System.Linq;
 6 using System.Text;
 7 using System.Threading.Tasks;
 8 using LC.Model.Common;
 9 using LC.Test;
10 using LC.Test.Model;
11 
12 namespace LC.Model
13 {
14     [Message(ConStr = "sql")]
15     public class SYS_User
16     {
17         [PrimaryKey]
18         public string Id { get; set; }
19         public string UserName { get; set; }
20 
21         public Guid? RoleId { get; set; }
22         public Guid? CityId { get; set; }
23         [Guidance(DepandField = "RoleId")]
24         public SYS_Role Role { get; set; }
25 
26         [Guidance(DepandField = "CityId")]
27         public City City { get; set; }
28 
29         public int Gender { get; set; }
30 
31         public bool Deleted { get; set; }
32 
33         public DateTime CreateTime { get; set; }
34     }
35 }

　　那么在生成sql的过程中，我需要知道实体所对应表的主键和外键关系，此关系我保存在类TableInfo中：

1  public class TableInfo
2     {
3         public string ConStr { get; set; }
4         public string RName { get; set; }
5         public string TableName { get; set; }
6         public string PrimaryKey { get; set; }
7         public Dictionary<string, TableInfo> ForeignRefs { get; set; }
8     }

　　具体怎么将实体类转换成TableInfo，在此我暂时使用反射，不过多解释，因为暂时还不知道有什么方法不用反射获取特性。

　　有了TableInfo，我们就可以轻松的生成Sql了。

查询命令生成器设计：

　　下面上图，这是我用画图工具话的，不要问我为什么，因为电脑没有建模工具。。。

　　

　　直接上代码：

　　

 1     public interface ICreator
 2     {
 3         SqlDebris Debris { get; set; }
 4     }
 5 
 6     public class BaseCreator : ICreator
 7     {
 8         public SqlDebris Debris { get; set; }
 9         public BaseCreator()
10         {
11             Debris = new SqlDebris();
12         }
13     }
14     public interface IQuery : ICreator
15     {
16         void CreateFrom(AnalysisTable data, TableInfo tableInfo);
17         void CreateSelect(AnalysisData data);
18         void CreateWhere(AnalysisData data);
19         void AppendOrder(AnalysisData data, OrderTypeEnum orderType);
20         void AppendSkip(int count);
21         void AppendTake(int count);
22         void GetCount();
23     }

　　下面是QueryCreator的实现：

  1  public class QueryCreator : BaseCreator, IQuery
  2     {
  3         public virtual void CreateSelect(AnalysisData data)
  4         {
  5             var primaryTable = data.Table;
  6             StringBuilder sb = new StringBuilder();
  7             //默认查询全部列
  8             if (data.StackList.Count <= 0)
  9             {
 10                 sb.AppendFormat("[{0}].*", primaryTable.RName);
 11             }
 12             else
 13             {
 14                 //查询部分列
 15                 for (int i = 0; i < data.StackList.Count; i += 3)
 16                 {
 17                     sb.AppendFormat("{0} {1} {2},", data.StackList[i], data.StackList[i + 1], data.StackList[i + 2]);
 18                 }
 19                 sb.Remove(sb.Length - 1, 1);
 20             }
 21             Debris.Select = sb.ToString();
 22         }
 23         public virtual void CreateFrom(AnalysisTable anlyTable, TableInfo tableInfo)
 24         {
 25             if (null == anlyTable)
 26             {
 27                 throw new BusinessException(BusinessRes.TableCanNotBeEmpty);
 28             }
 29             //默认排序信息
 30             if (string.IsNullOrEmpty(Debris.Order))
 31             {
 32                 Debris.Order = string.Format("[{0}].{1} {2}", anlyTable.RName, tableInfo.PrimaryKey, System.Enum.GetName(typeof(OrderTypeEnum), OrderTypeEnum.ASC));
 33             }
 34             StringBuilder sb = new StringBuilder();
 35             sb.AppendFormat("[{0}] AS [{1}]", anlyTable.Name, anlyTable.RName);
 36             AppendLeftJoinTables(anlyTable, tableInfo, sb);
 37             Debris.From = sb.ToString();
 38         }
 39         public virtual void CreateWhere(AnalysisData data)
 40         {
 41             if (data == null || data.StackList.Count() <= 0)
 42             {
 43                 return;
 44             }
 45             Debris.Where = string.Join(" ", data.StackList);
 46         }
 47         public virtual void AppendSkip(int count)
 48         {
 49             Debris.Skip = count;
 50         }
 51         public virtual void AppendTake(int count)
 52         {
 53             Debris.Take = count;
 54         }
 55         public virtual void AppendOrder(AnalysisData data, OrderTypeEnum orderType)
 56         {
 57             if (data.StackList.Count <= 0)
 58             {
 59                 return;
 60             }
 61             var field = data.StackList.First();
 62             StringBuilder sb = new StringBuilder(Debris.Order);
 63             if (string.IsNullOrEmpty(Debris.Order))
 64             {
 65                 sb.AppendFormat("{0} {1}", field, System.Enum.GetName(typeof(OrderTypeEnum), orderType));
 66                 Debris.Order = sb.ToString();
 67                 return;
 68             }
 69             sb.AppendFormat(",{0} {1}", field, System.Enum.GetName(typeof(OrderTypeEnum), orderType));
 70             Debris.Order = sb.ToString();
 71         }
 72         public void GetCount()
 73         {
 74             Debris.Select = "COUNT(1)";
 75         }
 76 
 77         private KeyValuePair<string, TableInfo> GetForeignReference(TableInfo tInfo, string rName)
 78         {
 79             var keyValue = tInfo.ForeignRefs.Where(u => u.Value.RName == rName).FirstOrDefault();
 80             if (string.IsNullOrEmpty(keyValue.Key))
 81             {
 82                 foreach (var item in tInfo.ForeignRefs)
 83                 {
 84                     var foreignTable = GetForeignReference(item.Value, rName);
 85                     if (!string.IsNullOrEmpty(keyValue.Key))
 86                     {
 87                         return foreignTable;
 88                     }
 89                 }
 90 
 91             }
 92 
 93             return keyValue;
 94         }
 95         private void AppendLeftJoinTables(AnalysisTable anlyTable, TableInfo tableInfo, StringBuilder sb)
 96         {
 97             ///添加关系表信息
 98             foreach (var item in anlyTable.leftJoins)
 99             {
100                 var _foreignRef = GetForeignReference(tableInfo, item.RName);
101                 if (string.IsNullOrEmpty(_foreignRef.Key))
102                 {
103                     throw new BusinessException(BusinessRes.WhitoutThisForeignReference);
104                 }
105                 sb.AppendFormat(" LEFT JOIN [{0}] AS [{1}] ON [{1}].{2}=[{3}].{4} ", item.Name, item.RName, _foreignRef.Value.PrimaryKey, anlyTable.RName, _foreignRef.Key);
106                 AppendLeftJoinTables(item, _foreignRef.Value, sb);
107             }
108         }
109     }

　　到此为止，生成的Sql依然是不完整的Sql碎片，我们需要将碎片合并成Sql语句，我写了一个工具类如下：

　　保存碎片类：

 1 public class SqlDebris
 2     {
 3         public string Where { get; set; }
 4         #region 查询
 5         public string From { get; set; }
 6         public string Select { get; set; }
 7         public string Order { get; set; }
 8         public int Skip { get; set; }
 9         public int? Take { get; set; }
10         #endregion
11         #region 修改
12         public string Set { get; set; }
13         public string Update { get; set; }
14         #endregion
15         #region 新增
16 
17         public string InsertTable { get; set; }
18         public string Columns { get; set; }
19         public string Values { get; set; }
20 
21         #endregion
22     }

　　通过下面工具类生成完整Sql语句：

 1 public class CommandTextHelper
 2     {
 3         public static string GetSelectCommandText(ICreator creator)
 4         {
 5             var debris = creator.Debris;
 6             StringBuilder sb = new StringBuilder();
 7             if (debris.Take == null)
 8             {
 9                 sb.Append(" SELECT * FROM (");
10             }
11             else
12             {
13                 //分页
14                 sb.AppendFormat(" SELECT TOP {0} * FROM (", debris.Take);
15             }
16             sb.AppendFormat("SELECT {0},ROW_NUMBER() OVER(ORDER BY  {2} ) as ROWNUMBER  FROM {1}", debris.Select, debris.From, debris.Order);
17             //条件
18             if (!string.IsNullOrEmpty(debris.Where))
19             {
20                 sb.AppendFormat(" WHERE {0} ", debris.Where);
21             }
22             sb.Append(") as NEW_TABLE ");
23             sb.AppendFormat(" WHERE ROWNUMBER>{0}", debris.Skip);
24             return sb.ToString();
25         }
26 
27         public static string GetCountCommandText(ICreator creator)
28         {
29             var debris = creator.Debris;
30             StringBuilder sb = new StringBuilder();
31 
32             sb.AppendFormat("SELECT {0} FROM {1}", debris.Select, debris.From);
33             //条件
34             if (!string.IsNullOrEmpty(debris.Where))
35             {
36                 sb.AppendFormat(" WHERE {0} ", debris.Where);
37             }
38             return sb.ToString();
39         }
40 
41         public static string GetUpdateCommandText(ICreator creator)
42         {
43             var debris = creator.Debris;
44             StringBuilder sb = new StringBuilder();
45             sb.AppendFormat("UPDATE {0} ", debris.Update);
46             sb.AppendFormat("SET {0} ", debris.Set);
47             sb.AppendFormat("WHERE {0}", debris.Where);
48             return sb.ToString();
49         }
50         public static string GetInsertCommandText(ICreator creator)
51         {
52             var debris = creator.Debris;
53             StringBuilder sb = new StringBuilder();
54             sb.AppendFormat("INSERT INTO {0}", debris.InsertTable);
55             sb.AppendFormat("({0}) ", debris.Columns);
56             sb.AppendFormat("VALUES({0})", debris.Values);
57             return sb.ToString();
58         }
59         public static string GetDeleteCommandText(ICreator creator)
60         {
61             var debris = creator.Debris;
62             StringBuilder sb = new StringBuilder();
63             sb.AppendFormat("DELETE FROM {0}", debris.From);
64             sb.AppendFormat(" WHERE {0}", debris.Where);
65             return sb.ToString();
66         }
67     }

　　下面是CommandFactory<TEntity>:

1  public class CommandFactory<TEntity> 
2     {
3         protected TableInfo _tableInfo;
4         public CommandFactory()
5         {
6             _tableInfo = new Mapper().MapToTable(typeof(TEntity));
7         }
8     }

　　

下面是QueryCommand<TEntity>实现:

 1  public class QueryCommand<TEntity> : CommandFactory<TEntity>
 2     {
 3         //sql碎片生成器
 4         private IQuery _creator;
 5         //查询参数
 6         private Dictionary<string, object> _params;
 7 
 8         private AnalysisTable _table;
 9 
10         public QueryCommand()
11         {
12             _creator = new QueryCreator();
13         }
14         public QueryCommand<TEntity> Where(Expression<Func<TEntity, bool>> exp)
15         {
16             var retData = new ExpressionAnalyzer(exp).GetAnalysisResult();
17             _creator.CreateWhere(retData);
18             _params = retData.ParamList;
19             _table = retData.Table;
20             return this;
21         }
22         public QueryCommand<TEntity> OrderBy(Expression<Func<TEntity, object>> exp)
23         {
24             _creator.AppendOrder(new ExpressionAnalyzer(exp).GetAnalysisResult(), OrderTypeEnum.ASC);
25             return this;
26         }
27         public QueryCommand<TEntity> OrderByDescding(Expression<Func<TEntity, object>> exp)
28         {
29             _creator.AppendOrder(new ExpressionAnalyzer(exp).GetAnalysisResult(), OrderTypeEnum.DESC);
30             return this;
31         }
32         public QueryCommand<TEntity> ThenBy(Expression<Func<TEntity, object>> exp)
33         {
34             return OrderBy(exp);
35         }
36         public QueryCommand<TEntity> ThenByDescding(Expression<Func<TEntity, object>> exp)
37         {
38             return OrderByDescding(exp);
39         }
40         public QueryCommand<TEntity> Skip(int count)
41         {
42             _creator.AppendSkip(count);
43             return this;
44         }
45         public QueryCommand<TEntity> Take(int count)
46         {
47             _creator.AppendTake(count);
48             return this;
49         }
50         public Command<TResult> GetSelectCommand<TResult>(Expression<Func<TEntity, TResult>> exp)
51         {
52             var _result = new ExpressionAnalyzer(exp, _table).GetAnalysisResult();
53             _creator.CreateSelect(_result);
54             _creator.CreateFrom(_result.Table, _tableInfo);
55             return new Command<TResult>()
56             {
57                 ConStr = _tableInfo.ConStr,
58                 CommandText = CommandTextHelper.GetSelectCommandText(_creator),
59                 Params = _params
60             };
61         }
62         public Command<int> GetCountCommand(Expression<Func<TEntity, bool>> exp)
63         {
64             var retData = new ExpressionAnalyzer(exp).GetAnalysisResult();
65             _creator.CreateWhere(retData);
66             _creator.GetCount();
67             _creator.CreateFrom(retData.Table, _tableInfo);
68             return new Command<int>()
69             {
70                 CommandText = CommandTextHelper.GetCountCommandText(_creator),
71                 ConStr = _tableInfo.ConStr,
72                 Params = retData.ParamList
73             };
74         }
75     }

　　下面是测试结果仅供参考：

 1         [TestMethod]
 2         public void TestQueryCommand()
 3         {
 4             var param = new SYS_User()
 5             {
 6                 UserName = "lichun",
 7                 RoleId = Guid.NewGuid()
 8             };
 9             QueryCommand<SYS_User> f = new QueryCommand<SYS_User>();
10             var command = f.Where(u => u.City.Name == "cengdu" && u.Role.Config.Name.Contains(param.UserName)).GetSelectCommand(u => new
11             {
12                 u.Id,
13                 u.Role.Name
14             });
15             ShowCommand(command);
16         }    
17 
18 
19         public void ShowCommand<TResult>(Command<TResult> command)
20         {
21 　　　　　　　Console.WriteLine("链接字符串：");
22             Console.WriteLine(command.ConStr);
23             Console.WriteLine("----------------------------------");
　　　　　　　　　Console.WriteLine("Sql命令：");
24             Console.WriteLine(command.CommandText);
25 
26             Console.WriteLine("----------------------------------");
27             if (command.Params != null)
28             {
　　　　　　　　　　　Console.WriteLine("参数：");
29                 foreach (var item in command.Params)
30                 {
31 
32                     Console.WriteLine("{0}  →  {1}", item.Key, item.Value);
33                 }
34             }
35 
36         }

测试结果如下：

　　

　　修改的ExpressionAnalyzer如下：

  1  public class ExpressionAnalyzer
  2     {
  3         /// <summary>
  4         /// 表达式所有参数集合
  5         /// </summary>
  6         private Dictionary<string, object> _params;
  7         /// <summary>
  8         /// 命名参数别名
  9         /// </summary>
 10         private const string _argName = "TAB";
 11         /// <summary>
 12         /// 解析结果
 13         /// </summary>
 14         private AnalysisData _resultData;
 15 
 16         public ExpressionAnalyzer()
 17         {
 18             _resultData = new AnalysisData();
 19             _params = new Dictionary<string, object>();
 20         }
 21         public ExpressionAnalyzer(LambdaExpression exp, AnalysisTable table = null)
 22             : this()
 23         {
 24             if (table != null)
 25             {
 26                 _resultData.Table = table;
 27             }
 28 
 29             if (exp != null)
 30             {
 31                 AppendParams(GetChildValue(exp.Body), _params);
 32                 foreach (var item in exp.Parameters)
 33                 {
 34                     AnalysisTables(item);
 35                 }
 36                 AnalysisExpression(exp.Body, true);
 37             }
 38         }
 39 
 40 
 41 
 42         public AnalysisData GetAnalysisResult()
 43         {
 44             return _resultData;
 45         }
 46 
 47 
 48         /// <summary>
 49         /// 解析表达式
 50         /// </summary>
 51         /// <param name="exp"></param>
 52         /// <param name="isLeftChild"></param>
 53         private void AnalysisExpression(Expression exp, bool isLeftChild = true)
 54         {
 55             switch (exp.NodeType)
 56             {
 57                 case ExpressionType.AndAlso:
 58                     _resultData.StackList.Add("(");
 59                     AnalysisExpression(GetChildExpression(exp));
 60                     _resultData.StackList.Add(")");
 61                     _resultData.StackList.Add("AND");
 62                     _resultData.StackList.Add("(");
 63                     AnalysisExpression(GetChildExpression(exp, false), false);
 64                     _resultData.StackList.Add(")");
 65                     break;
 66                 case ExpressionType.OrElse:
 67                     _resultData.StackList.Add("(");
 68                     AnalysisExpression(GetChildExpression(exp));
 69                     _resultData.StackList.Add(")");
 70                     _resultData.StackList.Add("OR");
 71                     _resultData.StackList.Add("(");
 72                     AnalysisExpression(GetChildExpression(exp, false), false);
 73                     _resultData.StackList.Add(")");
 74                     break;
 75                 case ExpressionType.Equal:
 76                     AnalysisExpression(GetChildExpression(exp));
 77                     _resultData.StackList.Add("=");
 78                     AnalysisExpression(GetChildExpression(exp, false), false);
 79                     break;
 80                 case ExpressionType.NotEqual:
 81                     AnalysisExpression(GetChildExpression(exp));
 82                     _resultData.StackList.Add("!=");
 83                     AnalysisExpression(GetChildExpression(exp, false), false);
 84                     break;
 85                 case ExpressionType.GreaterThanOrEqual:
 86                     AnalysisExpression(GetChildExpression(exp));
 87                     _resultData.StackList.Add(">=");
 88                     AnalysisExpression(GetChildExpression(exp, false), false);
 89                     break;
 90                 case ExpressionType.GreaterThan:
 91                     AnalysisExpression(GetChildExpression(exp));
 92                     _resultData.StackList.Add(">");
 93                     AnalysisExpression(GetChildExpression(exp, false), false);
 94                     break;
 95                 case ExpressionType.LessThan:
 96                     AnalysisExpression(GetChildExpression(exp));
 97                     _resultData.StackList.Add("<");
 98                     AnalysisExpression(GetChildExpression(exp, false), false);
 99                     break;
100                 case ExpressionType.LessThanOrEqual:
101                     AnalysisExpression(GetChildExpression(exp));
102                     _resultData.StackList.Add("<=");
103                     AnalysisExpression(GetChildExpression(exp, false), false);
104                     break;
105                 case ExpressionType.Call:
106                     var imExp = exp as MethodCallExpression;
107                     AnalysisExpression(imExp.Object, true);
108                     _resultData.StackList.Add("LIKE");
109                     if (imExp.Arguments.Count > 0)
110                     {
111                         var arg0 = imExp.Arguments[0] as MemberExpression;
112                         _resultData.StackList.Add("'%'+");
113                         AnalysisExpression(imExp.Arguments[0], false);
114                         _resultData.StackList.Add("+'%'");
115                     }
116                     break;
117                 case ExpressionType.MemberAccess:
118                     if (isLeftChild)
119                     {
120                         AnalysisTables(exp);
121                         var mberExp = exp as MemberExpression;
122                         var parentName = GetExpressionName(mberExp.Expression);
123                         if (!string.IsNullOrEmpty(parentName))
124                         {
125                             _resultData.StackList.Add(string.Format("[{0}].{1}", parentName, GetExpressionName(exp)));
126                             break;
127                         }
128                         _resultData.StackList.Add(GetExpressionName(exp));
129                     }
130                     else
131                     {
132                         var paramName = GetParamName(exp);
133                         _resultData.ParamList.Add(paramName, _params[paramName]);
134                         _resultData.StackList.Add(paramName);
135                     }
136                     break;
137                 case ExpressionType.Constant:
138                     var constent = exp as ConstantExpression;
139                     if (constent.Value == null)
140                     {
141                         var op = _resultData.StackList.ElementAt(_resultData.StackList.Count - 1);
142                         _resultData.StackList.RemoveAt(_resultData.StackList.Count - 1);
143                         if (string.Equals(op, "="))
144                         {
145                             _resultData.StackList.Add("IS NULL");
146                         }
147                         else
148                         {
149                             _resultData.StackList.Add("IS NOT NULL");
150                         }
151                         break;
152                     }
153                     if (constent.Value.GetType() == typeof(String))
154                     {
155                         _resultData.StackList.Add(string.Format("'{0}'", constent.Value));
156                         break;
157                     }
158                     if (constent.Value.GetType() == typeof(bool))
159                     {
160                         if (_resultData.StackList.Count > 0)
161                         {
162                             var value = Convert.ToBoolean(constent.Value);
163                             _resultData.StackList.Add(string.Format("{0}", value ? "1" : "0"));
164                         }
165 
166                         break;
167                     }
168                     _resultData.StackList.Add(string.Format("{0}", constent.Value));
169                     break;
170                 case ExpressionType.Convert:
171                     var uExp = exp as UnaryExpression;
172                     AnalysisExpression(uExp.Operand, isLeftChild);
173                     break;
174                 case ExpressionType.New:
175                     var newExp = exp as NewExpression;
176                     //解析查询字段
177                     for (int i = 0; i < newExp.Arguments.Count; i++)
178                     {
179                         AnalysisExpression(newExp.Arguments[i]);
180                         _resultData.StackList.Add("AS");
181                         _resultData.StackList.Add(string.Format("'{0}'", newExp.Members[i].Name));
182                     }
183                     break;
184                 case ExpressionType.Parameter:
185                     throw new BusinessException(BusinessRes.SelectObjectMastBeAnNewObject);
186                 //AnalysisExpression(Expression.New(exp.Type));
187                 //break;
188                 default:
189                     break;
190             }
191 
192         }
193         /// <summary>
194         /// 获取孩子节点
195         /// </summary>
196         /// <param name="exp"></param>
197         /// <param name="getLeft"></param>
198         /// <returns></returns>
199         private Expression GetChildExpression(Expression exp, bool getLeft = true)
200         {
201             var className = exp.GetType().Name;
202             switch (className)
203             {
204                 case "BinaryExpression":
205                 case "LogicalBinaryExpression":
206                     var bExp = exp as BinaryExpression;
207                     return getLeft ? bExp.Left : bExp.Right;
208                 case "PropertyExpression":
209                 case "FieldExpression":
210                     var mberExp = exp as MemberExpression;
211                     return mberExp;
212                 case "MethodBinaryExpression":
213                     var mbExp = exp as BinaryExpression;
214                     return getLeft ? mbExp.Left : mbExp.Right;
215                 case "UnaryExpression":
216                     var unaryExp = exp as UnaryExpression;
217                     return unaryExp;
218                 case "ConstantExpression":
219                     var cExp = exp as ConstantExpression;
220                     return cExp;
221                 case "InstanceMethodCallExpressionN":
222                     var imExp = exp as MethodCallExpression;
223                     return imExp;
224                 default:
225                     return null;
226             }
227         }
228         /// <summary>
229         /// 获取变量名
230         /// </summary>
231         /// <param name="exp"></param>
232         /// <param name="isLeftChild"></param>
233         /// <returns></returns>
234         private string GetExpressionName(Expression exp)
235         {
236             var className = exp.GetType().Name;
237             switch (className)
238             {
239                 case "PropertyExpression":
240                 case "FieldExpression":
241                     var mberExp = exp as MemberExpression;
242                     return string.Format("{0}", mberExp.Member.Name);
243                 case "TypedParameterExpression":
244                     return _argName;
245                 default:
246                     return string.Empty;
247             }
248         }
249         /// <summary>
250         /// 获取参数名
251         /// </summary>
252         /// <param name="exp"></param>
253         /// <param name="isLeftChild"></param>
254         /// <returns></returns>
255         private string GetParamName(Expression exp)
256         {
257             var className = exp.GetType().Name;
258             switch (className)
259             {
260                 case "PropertyExpression":
261                 case "FieldExpression":
262                     var mberExp = exp as MemberExpression;
263                     return string.Format("@{0}", mberExp.Member.Name);
264                 case "TypedParameterExpression":
265                     var texp = exp as ParameterExpression;
266                     return string.Format("@{0}", texp.Name);
267                 default:
268                     return string.Empty;
269             }
270         }
271         /// <summary>
272         /// 解析表信息
273         /// </summary>
274         /// <param name="exp"></param>
275         /// <param name="refTable">引用表</param>
276         private void AnalysisTables(Expression exp, AnalysisTable refTable = null)
277         {
278             var className = exp.GetType().Name;
279             switch (className)
280             {
281                 case "PropertyExpression":
282                 case "FieldExpression":
283                     var mberExp = exp as MemberExpression;
284                     if (IsDefaultType(mberExp.Type))
285                     {
286                         AnalysisTables(mberExp.Expression);
287                         break;
288                     }
289                     var _tampTab = GetTableByRName(_resultData.Table, mberExp.Member.Name);
290                     if (_tampTab == null)
291                     {
292                         _tampTab = new AnalysisTable()
293                          {
294                              RName = mberExp.Member.Name,
295                              Name = mberExp.Type.Name,
296                              TableType = mberExp.Type
297 
298                          };
299                         AnalysisTables(mberExp.Expression, _tampTab);
300                     }
301                     if (refTable != null)
302                     {
303                         _tampTab.leftJoins.Add(refTable);
304                     }
305                     break;
306                 case "TypedParameterExpression":
307                     //命名参数表达式
308                     var texp = exp as ParameterExpression;
309                     if (!IsDefaultType(texp.Type))
310                     {
311                         if (null == _resultData.Table)
312                         {
313                             _resultData.Table = new AnalysisTable()
314                              {
315                                  RName = _argName,
316                                  Name = texp.Type.Name,
317                                  TableType = texp.Type
318                              };
319                         }
320                         if (refTable != null)
321                         {
322                             _resultData.Table.leftJoins.Add(refTable);
323                         }
324                     }
325                     break;
326                 default:
327                     break;
328             }
329         }
330         /// <summary>
331         /// 遍历树，深度优先
332         /// </summary>
333         /// <param name="table"></param>
334         /// <param name="rName"></param>
335         /// <returns></returns>
336         private AnalysisTable GetTableByRName(AnalysisTable table, string rName)
337         {
338             var _tempTable = table;
339             if (_tempTable.RName == rName)
340             {
341                 return _tempTable;
342             }
343             foreach (var item in _tempTable.leftJoins)
344             {
345                 _tempTable = GetTableByRName(item, rName);
346                 if (_tempTable != null)
347                 {
348                     return _tempTable;
349                 }
350             }
351             return null;
352         }
353         /// <summary>
354         /// 解析获取表达式的值
355         /// </summary>
356         /// <param name="exp"></param>
357         /// <param name="leftChild"></param>
358         /// <returns></returns>
359         private object GetChildValue(Expression exp)
360         {
361             var className = exp.GetType().Name;
362             switch (className)
363             {
364                 case "BinaryExpression":
365                 case "LogicalBinaryExpression":
366                     var lExp = exp as BinaryExpression;
367                     var ret = GetChildValue(lExp.Left);
368                     if (IsNullDefaultType(ret))
369                     {
370                         ret = GetChildValue(lExp.Right);
371                     }
372                     return ret;
373                 case "MethodBinaryExpression":
374                     var mbExp = exp as BinaryExpression;
375                     var ret1 = GetChildValue(mbExp.Left);
376                     if (IsNullDefaultType(ret1))
377                     {
378                         ret1 = GetChildValue(mbExp.Right);
379                     }
380                     return ret1;
381 
382                 case "PropertyExpression":
383                 case "FieldExpression":
384                     var mberExp = exp as MemberExpression;
385                     return GetChildValue(mberExp.Expression);
386                 case "ConstantExpression":
387                     var cExp = exp as ConstantExpression;
388                     return cExp.Value;
389                 case "UnaryExpression":
390                     var unaryExp = exp as UnaryExpression;
391                     return GetChildValue(unaryExp.Operand);
392                 case "InstanceMethodCallExpressionN":
393                     var imExp = exp as MethodCallExpression;
394                     if (imExp.Arguments.Count > 0)
395                     {
396                         return GetChildValue(imExp.Arguments[0]);
397                     }
398                     return null;
399                 default:
400                     return null;
401             }
402 
403         }
404         /// <summary>
405         /// 初始化所有参数
406         /// </summary>
407         /// <param name="paramObj"></param>
408         private void AppendParams(object paramObj, Dictionary<string, object> _params)
409         {
410             if (IsNullDefaultType(paramObj))
411             {
412                 return;
413             }
414             if (_params == null)
415             {
416                 _params = new Dictionary<string, object>();
417             }
418             foreach (var item in paramObj.GetType().GetProperties())
419             {
420                 if (IsDefaultType(item.PropertyType))
421                 {
422                     var value = item.GetValue(paramObj, null);
423                     if (value != null)
424                     {
425                         _params.Add(string.Format("@{0}", item.Name), value);
426                     }
427                     continue;
428                 }
429 
430                 AppendParams(item.GetValue(paramObj), _params);
431             }
432 
433             foreach (var item in paramObj.GetType().GetFields())
434             {
435                 if (IsDefaultType(item.FieldType))
436                 {
437                     var value = item.GetValue(paramObj);
438                     if (value != null)
439                     {
440                         _params.Add(string.Format("@{0}", item.Name), value);
441                     }
442                     continue;
443                 }
444                 AppendParams(item.GetValue(paramObj), _params);
445             }
446         }
447         public Dictionary<string, object> GetParams(object paramObj)
448         {
449             Dictionary<string, object> dicParams = new Dictionary<string, object>();
450             AppendParams(paramObj, dicParams);
451             return dicParams;
452         }
453         /// <summary>
454         /// 判断是否是系统默认基本类型
455         /// </summary>
456         /// <param name="type"></param>
457         /// <returns></returns>
458         private bool IsNullDefaultType(object obj)
459         {
460             if (obj == null)
461             {
462                 return true;
463             }
464             return IsDefaultType(obj.GetType());
465         }
466         private bool IsDefaultType(Type type)
467         {
468             string defaultType = @"String|Boolean|Double|Int32|Int64|Int16|Single|DateTime|Decimal|Char|Object|Guid";
469 
470             Regex e = new Regex(defaultType, RegexOptions.IgnoreCase);
471             if (type.Name.ToLower().Contains("nullable"))
472             {
473                 if (type.GenericTypeArguments.Count() > 0)
474                 {
475                     return e.IsMatch(type.GenericTypeArguments[0].Name);
476                 }
477             }
478             return e.IsMatch(type.Name);
479         }
480     }

　　共同学习共同进步，表达有些乱，希望各位大神多多包涵。