重构ConditionHelper

　　在上一篇日志写了ConditionHelper的具体实现方法和它的用法，但那时只是把心里所想的一个思路用代码记录下来，而没有经过实践检 验的，难免存在一些问题，但在最近的一个新项目中用到ConditionHelper时，才发现其中问题不少，最简单的问题是方法名取得有问题，如 AddAndCondition、AddOrCondition等，不注意的话很容易弄错，所以在重构的过程把这些方法合并成了一个方法，另外还有在使用 时如遇到一些特殊情况还会出错，在重构后把这些问题都修复了，至少用了一两个星期了没有发现新的Bug,但也不能保证不存在Bug了，只能说应该基本是没 什么问题了。

　　在使用ConditionHelper的过程中，自己觉得比以前用的方法方便很多了，写出来的代码也精简了不少，看着都舒服些。

　 　以前本来想着改进后直接把上一篇日志修改一下就行了，但自己觉得重构后的代码与重构前的代码有很大的区别，所以想着也没必要把以前不好的东西直接一笔抹 杀，这样也方便以后看看其中的区别。自己最近在重新写框架时，看着以前写的框架有很多地方是写得很啰嗦的，但自己当时并没有这么觉得，有时代码隔一段时间 回头来看你就会发现原来还可以这样精简一下，这并不一定是水平提高的原因，人有时一心放在一件事情上反而不能把事情做好，偶尔把自己的视线移到别的地方， 再回头来看，也许你会发觉原来还可以这样子写。

　　好了，废话不多说了，以下是重构后的全部代码：　　　　　　

     #region  public enum Comparison
       public enum Comparison
       {
           /// <summary>
           /// 等于号 =
           /// </summary>
           Equal,
           /// <summary>
           /// 不等于号 <>
          /// </summary>
          NotEqual,
          /// <summary>
          /// 大于号 >
          /// </summary>
          GreaterThan,
          /// <summary>
          /// 大于或等于 >=
          /// </summary>
          GreaterOrEqual,
          /// <summary>
          /// 小于 <
 22         /// </summary>
          LessThan,
          /// <summary>
          /// 小于或等于 <=
 26         /// </summary>
          LessOrEqual,
          /// <summary>
          /// 模糊查询 Like
          /// </summary>
          Like,
          /// <summary>
          /// 模糊查询  Not Like
          /// </summary>
          NotLike,
          /// <summary>
          /// is null
          /// </summary>
          IsNull,
          /// <summary>
          /// is not null
          /// </summary>
          IsNotNull,
          /// <summary>
          /// in
          /// </summary>
          In,
          /// <summary>
          /// not in
          /// </summary>
          NotIn,
          /// <summary>
          /// 左括号 （
          /// </summary>
          OpenParenthese,
          /// <summary>
          /// 右括号 )
          /// </summary>
          CloseParenthese,
          Between,
          StartsWith,
          EndsWith
      }
      #endregion

      #region public enum RelationType
      /// <summary>
      /// 关联类型：And、Or
      /// </summary>
      public enum RelationType
      {
          AND,
          OR,
      }
      #endregion

      /// <summary>
      /// 文件名：ConditionHelper
      /// 功能描述：条件帮助类
      /// </summary>
      public class ConditionHelper
      {
          #region 变量、属性定义
          string parameterPrefix = "@";
          string parameterKey = "P";
          /// <summary>
          /// 用来拼接SQL语句
          /// </summary>
          StringBuilder conditionBuilder = new StringBuilder();
          /// <summary>
          /// 为True时表示字段为空或者Null时则不作为查询条件
          /// </summary>
          bool isExcludeEmpty = true;
          /// <summary>
          /// 是否生成带参数的sql
          /// </summary>
          bool isBuildParameterSql = true;

         #region public List<SqlParameter> ParameterList
         private List<SqlParameter> parameterList = new List<SqlParameter>();
         /// <summary>
         /// 参数列表
         /// </summary>
         public List<SqlParameter> ParameterList
         {
             get { return this.parameterList; }
         }
         #endregion

         int index = ;

         #endregion

         #region 构造函数
         /// <summary>
         /// 创建ConditionHelper对象
         /// </summary>
         /// <param name="isExcludeEmpty">为True时表示字段为空或者Null时则不作为查询条件</param>
         /// <param name="isBuildParameterSql">是否生成带参数的sql</param>
         /// <param name="parameterKey">参数的前辍</param>
         public ConditionHelper(bool isExcludeEmpty = true, string parameterKey = "P", bool isBuildParameterSql = true)
         {
             this.isExcludeEmpty = isExcludeEmpty;
             this.isBuildParameterSql = isBuildParameterSql;
             this.parameterKey = parameterKey;
             this.conditionBuilder.Append(" Where ");
         }
         #endregion

         #region 公共方法
         #region  public ConditionHelper Clear()  清除已添加的条件
         /// <summary>
         /// 清除已添加的条件
         /// </summary>
         /// <returns></returns>
         public ConditionHelper Clear()
         {
             parameterList.Clear();
             conditionBuilder.Clear().Append(" Where ");
             return this;
         }
         #endregion

         #region public ConditionHelper AppendCondition(RelationType relationType, string fieldName, Comparison comparison, params object[] fieldValue) 添加条件
         /// <summary>
         /// 添加条件
         /// </summary>
         /// <param name="relationType">关联运算符</param>
         /// <param name="comparison">比较符类型</param>
         /// <param name="fieldName">字段名称</param>
         /// <param name="fieldValue">字段值，注：1、不可为数组;2、Between时，此字段必须填两个值; </param>
         /// <returns>返回ConditionHelper</returns>
         public ConditionHelper AppendCondition(RelationType relationType, string fieldName, Comparison comparison, params object[] fieldValue)
         {
             if (IsContinue(fieldValue)) return this;

             if (!this.conditionBuilder.ToString().Trim().EndsWith("WHERE", StringComparison.InvariantCultureIgnoreCase))
             {
                 this.conditionBuilder.Append(GetRelationString(relationType));
             }
             this.AppendCondition(fieldName, comparison, fieldValue);
             return this;
         }
         #endregion

         #region public ConditionHelper AppendCondition(string fieldName, Comparison comparison, params object[] fieldValue)
         /// <summary>
         /// 添加条件
         /// </summary>
         /// <param name="comparison">比较符类型</param>
         /// <param name="fieldName">字段名称</param>
         /// <param name="fieldValue">字段值，注：1、不可为数组;2、Between时，此字段必须填两个值; </param>
         /// <returns>返回ConditionHelper</returns>
         public ConditionHelper AppendCondition(string fieldName, Comparison comparison, params object[] fieldValue)
         {
             if (IsContinue(fieldValue)) return this;

             switch (comparison)
             {
                 case Comparison.Equal:
                 case Comparison.NotEqual:
                 case Comparison.GreaterThan:
                 case Comparison.GreaterOrEqual:
                 case Comparison.LessThan:
                 case Comparison.LessOrEqual:
                     this.conditionBuilder.AppendFormat("{0}{1}{2}", GetFieldName(fieldName), GetComparisonOperator(comparison), GetFieldValue(fieldValue[]));
                     break;
                 case Comparison.IsNull:
                 case Comparison.IsNotNull:
                     this.conditionBuilder.AppendFormat("{0}{1}", GetFieldName(fieldName), GetComparisonOperator(comparison));
                     break;
                 case Comparison.Like:
                 case Comparison.NotLike:
                     this.conditionBuilder.AppendFormat("{0}{1}{2}", GetFieldName(fieldName), GetComparisonOperator(comparison), GetFieldValue(string.Format("%{0}%", fieldValue[])));
                     break;
                 case Comparison.In:
                 case Comparison.NotIn:
                     this.conditionBuilder.AppendFormat("{0}{1}({2})", GetFieldName(fieldName), GetComparisonOperator(comparison), string.Join(",", GetFieldValue(fieldValue)));
                     break;
                 case Comparison.StartsWith:
                     this.conditionBuilder.AppendFormat("{0}{1}{2}", GetFieldName(fieldName), GetComparisonOperator(comparison), GetFieldValue(string.Format("{0}%", fieldValue[])));
                     break;
                 case Comparison.EndsWith:
                     this.conditionBuilder.AppendFormat("{0}{1}{2}", GetFieldName(fieldName), GetComparisonOperator(comparison), GetFieldValue(string.Format("%{0}", fieldValue[])));
                     break;
                 case Comparison.Between:
                     this.conditionBuilder.AppendFormat("{0}{1}{2} AND {3}", GetFieldName(fieldName), GetComparisonOperator(comparison), GetFieldValue(fieldValue[]), GetFieldValue(fieldValue[]));
                     break;
                 default:
                     throw new Exception("条件为定义");
             }
             return this;
         }
         #endregion

         #region public ConditionHelper AppendParenthese(RelationType relationType, ConditionHelper condition)
         /// <summary>
         /// 添加含有括号的条件
         /// </summary>
         /// <param name="relationType">关联运算符</param>
         /// <param name="condition">条件</param>
         /// <returns></returns>
         public ConditionHelper AppendParenthese(RelationType relationType, ConditionHelper condition)
         {
             if (condition == null || condition.conditionBuilder.ToString().Trim().Length < )
                 return this;
             if (!conditionBuilder.ToString().Trim().EndsWith("WHERE", StringComparison.InvariantCultureIgnoreCase))
             {
                 this.conditionBuilder.Append(GetRelationString(relationType));
             }
             this.conditionBuilder.AppendFormat(" ({0}) ", condition.conditionBuilder.ToString().Remove(, ));
             if (condition.parameterList.Count > )
             {
                 this.parameterList.AddRange(condition.parameterList);
             }
             return this;
         }
         #endregion

         #region public override string ToString()
         /// <summary>
         /// 转化成Sql条件语句：（包含Where关键字）
         /// </summary>
         /// <returns></returns>
         public override string ToString()
         {
             if (this.conditionBuilder.Length < )
                 return string.Empty;
             return this.conditionBuilder.ToString();
         }
         #endregion

         #endregion

         #region 私有方法
         /// <summary>
         /// 取得字段值
         /// </summary>
         /// <param name="fieldValue"></param>
         /// <returns></returns>
         private string GetFieldValue(params object[] fieldValue)
         {
             if (isBuildParameterSql == true)
             {
                 if (fieldValue.Length < )
                 {
                     return AddParameter(fieldValue[]);
                 }
                 else
                 {
                     List<string> parameterNameList = new List<string>();
                     foreach (var value in fieldValue)
                     {
                         parameterNameList.Add(AddParameter(value));
                     }
                     return string.Join(",", parameterNameList);
                 }
             }
             else
             {
                 if (fieldValue.Length < )
                 {
                     return string.Format("'{0}'", fieldValue[]);
                 }
                 else
                 {
                     return string.Format("'{0}'", string.Join("','", fieldValue));
                 }
             }
         }

         /// <summary>
         /// 添加参数
         /// </summary>
         /// <param name="fieldValue"></param>
         /// <returns></returns>
         private string AddParameter(object fieldValue)
         {
             index++;
             string parameterName = string.Format("{0}{1}{2}", parameterPrefix, parameterKey, index);
             this.parameterList.Add(new SqlParameter
              {
                  ParameterName = parameterName,
                  Value = fieldValue ?? DBNull.Value
              });
             return parameterName;
         }

         private string GetFieldName(string fieldName)
         {
             return string.Format("{0}", fieldName);
         }

         /// <summary>
         /// 用来判断是否跳过此拼接条件
         /// </summary>
         /// <param name="fieldValue">字段值</param>
         /// <returns>返回True表示跳过，否则不跳过</returns>
         private bool IsContinue(params object[] fieldValue)
         {
             bool result = false;
             //如果选择IsExcludeEmpty为True,并且该字段为空值的话则跳过
             if (isExcludeEmpty && fieldValue != null && fieldValue.Length >  && string.IsNullOrEmpty(fieldValue[] + ""))
                 result = true;
             return result;
         }

         /// <summary>
         /// 取得关联类型字符串
         /// </summary>
         /// <param name="relationType"></param>
         /// <returns></returns>
         private static string GetRelationString(RelationType relationType)
         {
             string result = string.Empty;
             switch (relationType)
             {
                 case RelationType.AND:
                     result = SqlKeyWords.AND;
                     break;
                 case RelationType.OR:
                     result = SqlKeyWords.OR;
                     break;
             }
             return result;
         }

         /// <summary>
         /// 取得关系运算符
         /// </summary>
         /// <param name="comparison"></param>
         /// <returns></returns>
         private static string GetComparisonOperator(Comparison comparison)
         {
             string result = string.Empty;
             switch (comparison)
             {
                 case Comparison.Equal:
                     result = " = ";
                     break;
                 case Comparison.NotEqual:
                     result = " <> ";
                     break;
                 case Comparison.GreaterThan:
                     result = " > ";
                     break;
                 case Comparison.GreaterOrEqual:
                     result = " >= ";
                     break;
                 case Comparison.LessThan:
                     result = " < ";
                     break;
                 case Comparison.LessOrEqual:
                     result = " <= ";
                     break;
                 case Comparison.Like:
                 case Comparison.StartsWith:
                 case Comparison.EndsWith:
                     result = " LIKE ";
                     break;
                 case Comparison.NotLike:
                     result = " NOT LIKE ";
                     break;
                 case Comparison.IsNull:
                     result = " IS NULL ";
                     break;
                 case Comparison.IsNotNull:
                     result = " IS NOT NULL ";
                     break;
                 case Comparison.In:
                     result = " IN ";
                     break;
                 case Comparison.NotIn:
                     result = " NOT IN ";
                     break;
                 case Comparison.OpenParenthese:
                     result = " (";
                     break;
                 case Comparison.CloseParenthese:
                     result = ") ";
                     break;
                 case Comparison.Between:
                     result = " BETWEEN ";
                     break;
                 default:
                     throw new Exception("条件未定义!");
             }
             return result;
         }
         #endregion

     }

　　重构后添加条件的方法就只有AppendCondition和AppendCondition的重载以及AppendParenthese三个方法，方法名字把Add改为Append，总觉得Add做为方法名有点怪怪的，AppendParenthese为添加含有括号的条件，在上一篇日志中的ConditionHelper中关于括号的条件组合是存在问题的，有时存在添加了左括号而没有右括号的情况，在重构号把左右括号放在一个方法里就不存在这个问题了。另外根据自己项目的需要，添加了Clear方法，以便清除先前添加进去的条件。

　　以下是我在一个项目中用到ConditionHelper的一个例子：

　　

         /// <summary>
         /// 通过登录账号和密码查找用户
         /// </summary>
         /// <param name="userID">登录账号</param>
         /// <param name="password">加密前的密码</param>
         /// <returns>返回用户信息</returns>
         public SysUserInfo FindByUser(string userID, string password)
         {
             if (string.IsNullOrEmpty(userID))
                 return null;
             password = Encrypt(password);
             ConditionHelper condition = new ConditionHelper();
             condition.AppendCondition(SysUserInfo.F_UserID, Comparison.Equal, userID)
                      .AppendCondition(RelationType.AND, SysUserInfo.F_Password, Comparison.Equal, password);
             return this.Find(condition);
         }