SqlHelper简单实现（通过Expression和反射）9.Sql表述对象SqlSession

此类是整个SqlHelper的另一个核心，基本思想就是通过EntityHelper，ObjectHelper和ExpressionHelper获取拼接Select语句的全部元素，拼接出完整Select语句。

 using System.Collections.Generic;
 using RA.DataAccess.Common;

 namespace RA.DataAccess
 {
     public partial class SqlSession<T>
     {
         public SqlSession()
         {
             Fields = EntityHelper.GetFields<T>(false);
             Field = EntityHelper.GetFiledString<T>();
             TableName = EntityHelper.GetTableName<T>();
             PrimaryKey = EntityHelper.GetPrimaryKey<T>();
         }
         /// <summary>
         /// 字段，用逗号隔开
         /// </summary>
         public string Field { get; set; }
         /// <summary>
         /// 主键
         /// </summary>
         public string PrimaryKey { get; set; }
         /// <summary>
         /// 表名
         /// </summary>
         public string TableName { get; set; }
         /// <summary>
         /// 字段列表
         /// </summary>
         public List<string> Fields { get; set; }
         /// <summary>
         /// 条件表达式
         /// </summary>
         public string WhereStr { get; set; } = "";
         /// <summary>
         /// 是否聚合
         /// </summary>
         public bool IsDistinct { get; set; }
         /// <summary>
         /// 排序
         /// </summary>
         public string OrderByStr { get; set; }
         /// <summary>
         /// 连表字符串
         /// </summary>
         public string JoinStr { get; set; }
         /// <summary>
         /// 完整sql
         /// </summary>
         public string SqlExpression
         {
             get
             {
                 var sql = "SELECT $distinct " + Field + " FROM " + TableName + " $join$where$orderby";

                 sql = sql.Replace("$distinct", IsDistinct ? "DISTINCT" : "");
                 sql = sql.Replace("$join", string.IsNullOrEmpty(JoinStr) ? "" : JoinStr);
                 sql = sql.Replace("$where", string.IsNullOrEmpty(WhereStr) ? "" : "WHERE " + WhereStr);
                 sql = sql.Replace("$orderby", string.IsNullOrEmpty(OrderByStr) ? "" : "ORDER BY " + OrderByStr);
                 return sql;
             }
         }
     }
 }

 using System;
 using System.Linq.Expressions;
 using RA.DataAccess.Common;

 namespace RA.DataAccess
 {
     public partial class SqlSession<T> where T : class
     {
         #region Where操作
         private void WhereSqlFromExpression(Expression func)
         {
             if (WhereStr != "")
             {
                 WhereStr = WhereStr + "AND " + ExpressionHelper.GetSqlByExpression(func) + " ";
             }
             else
             {
                 WhereStr = ExpressionHelper.GetSqlByExpression(func) + " ";
             }
         }
         /// <summary>
         /// Where操作，适用于单表查询(exp代表的元素的查询)
         /// </summary>
         /// <param name="func">表达式</param>
         public void Where(Expression<Func<T, bool>> func)
         {
             WhereSqlFromExpression(func.Body);
         }
         /// <summary>
         /// Where操作，适用于单表查询(Target中元素的查询)
         /// </summary>
         /// <typeparam name="Target">要查询的另一个表的实体</typeparam>
         /// <param name="func"></param>
         public void Where<Target>(Expression<Func<Target, bool>> func)
         {
             WhereSqlFromExpression(func.Body);
         }
         /// <summary>
         /// Where操作，适用于联表查询时的where语句(exp和T元素的关系查询)
         /// </summary>
         /// <typeparam name="Target"></typeparam>
         /// <param name="func"></param>
         public void Where<Target>(Expression<Func<Target, T, bool>> func)
         {
             WhereSqlFromExpression(func.Body);
         }
         /// <summary>
         /// Where操作，适用于多联表时的where语句（TSource和Target元素之间的关系查询）
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="Target"></typeparam>
         /// <param name="func"></param>
         public void Where<TSource, Target>(Expression<Func<TSource, Target, bool>> func)
         {
             WhereSqlFromExpression(func.Body);
         }

         /// <summary>
         /// Where操作，适用于多联表时的where语句（多条件，跨表）
         /// </summary>
         /// <typeparam name="T0"></typeparam>
         /// <typeparam name="T1"></typeparam>
         /// <typeparam name="T2"></typeparam>
         /// <param name="func"></param>
         public void Where<T0, T1, T2>(Expression<Func<T0, T1, T2, bool>> func)
         {
             WhereSqlFromExpression(func.Body);
         }

         /// <summary>
         /// Where操作，适用于多联表时的where语句（多条件，跨表）
         /// </summary>
         /// <typeparam name="T0"></typeparam>
         /// <typeparam name="T1"></typeparam>
         /// <typeparam name="T2"></typeparam>
         /// <typeparam name="T3"></typeparam>
         /// <param name="func"></param>
         public void Where<T0, T1, T2, T3>(Expression<Func<T0, T1, T2, T3, bool>> func)
         {
             WhereSqlFromExpression(func.Body);
         }

         /// <summary>
         /// Where操作，适用于多联表时的where语句（多条件，跨表）
         /// </summary>
         /// <typeparam name="T0"></typeparam>
         /// <typeparam name="T1"></typeparam>
         /// <typeparam name="T2"></typeparam>
         /// <typeparam name="T3"></typeparam>
         /// <typeparam name="T4"></typeparam>
         /// <param name="func"></param>
         public void Where<T0, T1, T2, T3, T4>(Expression<Func<T0,T1,T2,T3,T4,bool>> func)
         {
             WhereSqlFromExpression(func.Body);
         }
         #endregion

         #region 排序
         /// <summary>
         /// 按照DESC排序
         /// </summary>
         /// <param name="func"></param>
         public void OrderByDescending(Expression<Func<T, object>> func)
         {
             OrderByStr = ExpressionHelper.GetSqlByExpression(func.Body) + "DESC ";
         }

         /// <summary>
         /// 排序
         /// </summary>
         /// <param name="func"></param>
         public void OrderBy(Expression<Func<T, object>> func)
         {
             OrderByStr = ExpressionHelper.GetSqlByExpression(func.Body) + " ";
         }
         #endregion

         #region 连接
         /// <summary>
         ///join表链接(exp和Target表相连时使用此方法)
         /// </summary>
         /// <typeparam name="Target"></typeparam>
         /// <param name="func"></param>
         public void Join<Target>(Expression<Func<Target,T,bool>> func)
         {
             var targetfields = "," + EntityHelper.GetFiledString<Target>();
             Field += targetfields;
             JoinStr += "INNER JOIN " + EntityHelper.GetTableName<Target>() + " ON ";
             JoinStr += ExpressionHelper.GetSqlByExpression(func.Body) + " ";
         }

         /// <summary>
         /// join表连接(TSource和Target表相连时使用此方法)
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="Target"></typeparam>
         /// <param name="func"></param>
         public void Join<TSource, Target>(Expression<Func<TSource, Target, bool>> func)
         {
             if (!Field.Contains(EntityHelper.GetFiledString<TSource>()))
             {
                 throw new NotSupportedException("联表时还没有联接: " + EntityHelper.GetTableName<TSource>());
             }
             var targetfields = "," + EntityHelper.GetFiledString<Target>();
             Field += targetfields;
             JoinStr += "INNER JOIN " + EntityHelper.GetTableName<Target>() + " ON ";
             JoinStr += ExpressionHelper.GetSqlByExpression(func.Body) + " ";
         }
         #endregion

         #region 左连接
         /// <summary>
         /// 左连接
         /// </summary>
         /// <typeparam name="Target"></typeparam>
         /// <param name="func"></param>
         public void LeftJoin<Target>(Expression<Func<Target, T, bool>> func)
         {
             Field += "," + EntityHelper.GetFiledString<Target>();
             JoinStr += "LEFT JOIN " + EntityHelper.GetTableName<Target>() + " ON ";
             JoinStr += ExpressionHelper.GetSqlByExpression(func.Body) + " ";
         }

         /// <summary>
         /// 左连接（条件中不包括exp）
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="Target"></typeparam>
         /// <param name="func"></param>
         public void LeftJoin<TSource, Target>(Expression<Func<TSource, Target, bool>> func)
         {
             if (!Field.Contains(EntityHelper.GetFiledString<TSource>()))
             {
                 throw new NotSupportedException("联表时还没有联接: " + EntityHelper.GetTableName<TSource>());
             }
             Field += "," + EntityHelper.GetFiledString<Target>();
             JoinStr += "LEFT JOIN " + EntityHelper.GetTableName<Target>() + " ON ";
             JoinStr += ExpressionHelper.GetSqlByExpression(func.Body) + " ";
         }
         #endregion

         #region 右连接
         /// <summary>
         /// 右连接
         /// </summary>
         /// <typeparam name="Target"></typeparam>
         /// <param name="func"></param>
         public void RightJoin<Target>(Expression<Func<Target, T, bool>> func)
         {
             Field += "," + EntityHelper.GetFiledString<Target>();
             JoinStr += "RIGHT JOIN " + EntityHelper.GetTableName<Target>() + " ON ";
             JoinStr += ExpressionHelper.GetSqlByExpression(func.Body) + " ";
         }

         /// <summary>
         /// 右连接（条件中不包括exp）
         /// </summary>
         /// <typeparam name="TSource"></typeparam>
         /// <typeparam name="Target"></typeparam>
         /// <param name="func"></param>
         public void RightJoin<TSource, Target>(Expression<Func<TSource, Target, bool>> func)
         {
             if (!Field.Contains(EntityHelper.GetFiledString<TSource>()))
             {
                 throw new NotSupportedException("联表时还没有联接: " + EntityHelper.GetTableName<TSource>());
             }
             Field += "," + EntityHelper.GetFiledString<Target>();
             JoinStr += "RIGHT JOIN " + EntityHelper.GetTableName<Target>() + " ON ";
             JoinStr += ExpressionHelper.GetSqlByExpression(func.Body) + " ";
         }
         #endregion

         /// <summary>
         /// 排重
         /// </summary>
         public void Distinct()
         {
             IsDistinct = true;
         }
     }
 }