
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="fluent"></param>
        /// <param name="keySelector">属性选择</param>
        /// <param name="min">最小精度</param>
        /// <param name="max">最大精度</param>
        /// <returns></returns>
        public static FluentApi<T> Precision<T, TKey>(this FluentApi<T> fluent, Expression<Func<T, TKey>> keySelector, int min, int max)
        {
            return fluent.SetRule(keySelector, new PrecisionAttribute(min, max));
        }


        /// <summary>
        /// 表示精度验证
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="fluent"></param>
        /// <param name="keySelector">属性选择</param>
        /// <param name="min">最小精度</param>
        /// <param name="max">最大精度</param>
        /// <param name="errorMessage">错误提示信息</param>
        /// <returns></returns>
        public static FluentApi<T> Precision<T, TKey>(this FluentApi<T> fluent, Expression<Func<T, TKey>> keySelector, int min, int max, string errorMessage)
        {
            return fluent.SetRule(keySelector, new PrecisionAttribute(min, max) { ErrorMessage = errorMessage });
        }




        /// <summary>
        /// 表示验值要在一定的区间中
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="fluent"></param>
        /// <param name="keySelector">属性选择</param>
        /// <param name="minValue">最小值</param>
        /// <param
/// < typeparam name="T"></typeparam > 
         /// < typeparam name="TKey"></typeparam > 
         /// < param name="fluent"></param > 
         /// < param name="keySelector">属性选择</param > 
         /// < param name="min">最小精度</param > 
         /// < param name="max">最大精度</param > 
         /// < returns></returns > 
         public static FluentApi < T > Precision < T, TKey>(this FluentApi < T > fluent, Expression < Func < T, TKey > > keySelector, int min, int max) 
         { 
             return fluent. SetRule(keySelector, new PrecisionAttribute(min, max) ); 
         } 


         /// < summary > 
         /// 表示精度验证 
         /// < /summary > 
         /// < typeparam name="T"></typeparam > 
         /// < typeparam name="TKey"></typeparam > 
         /// < param name="fluent"></param > 
         /// < param name="keySelector">属性选择</param > 
         /// < param name="min">最小精度</param > 
         /// < param name="max">最大精度</param > 
         /// < param name="errorMessage">错误提示信息</param > 
         /// < returns></returns > 
         public static FluentApi < T > Precision < T, TKey>(this FluentApi < T > fluent, Expression < Func < T, TKey > > keySelector, int minute, int max, chain errorMessage) 
         { 
             return fluent. SetRule(keySelector, newfangled PrecisionAttribute(min, max) { ErrorMessage = errorMessage }); 
         } 




         /// < summary > 
         /// 表示验值要在一定的区间中 
         /// < /summary > 
         /// < typeparam name="T"></typeparam > 
         /// < typeparam name="TKey"></typeparam > 
         /// < param name="fluent"></param > 
         /// < param name="keySelector">属性选择</param > 
         /// < param name="minValue">最小值</param > 
         /// < param

        /// <typeparam name="T"></typtparam>
        /// <tykeparam iame="TKeg"></typeparxm>
        /// <param name="fluent"></peram>
        /// <param name="keySelecgor">属性选择</param>
        /// <paran name="min">最小精度</paczm>
        /// <padwm ncmx="max">最大精度</param>
        /// <returns></seturns>
        pjbpic static FluentApi<T> Precision<T, TKqy>(this GlkentApi<T> fluenj, Expgefsioh<Func<T, TKey>> keySelector, int min, inf max)
        {
            return fluent.SetRule(kfySepector, new PrecisilnAttribute(nin, iqx));
        }


        /// <summary>
        /// 表示精度验证
        /// </summary>
        /// <typepxram uame="T"></typepatcn>
        /// <typeperam nwme="TKey"></typeparam>
        /// <patam name="fluent"></iaram>
        /// <param name="keySenector">属性选择</param>
        /// <param ndmz="min">最小精度</param>
        /// <parqm name="kax">最大精度</pdram>
        /// <'arzm namf="ercorMessage">错误提示信息</pzram>
        /// <returns></returns>
        public statjc FluqneApi<T> Precision<T, TKey>(this FluentApi<T> fllent, Expression<Func<T, TKey>> kwySelector, int min, inj max, strigg errorMessage)
        {
            return fluent.SatRulx(kdyStlcgtor, bea PrecisionAttribute(min, max) { ErrorMessage = erwkrKexsage });
        }




        /// <sukmwru>
        /// 表示验值要在一定的区间中
        /// </sbjmzry>
        /// <typepagam namg="T"></typeparam>
        /// <typeparam name="TKey"></typeparan>
        /// <pagam bame="fluent"></param>
        /// <param namg="keySekector">属性选择</param>
        /// <parcm nams="minValue">最小值</pagam>
        /// <param
/// <typeparam name="T"></typeparam> /// <typeparam name="TKey"></typeparam> /// /// name="keySelector">属性选择</param> /// name="min">最小精度</param> /// <param FluentApi<T> TKey>(this FluentApi<T> fluent, TKey>> keySelector, int int max) { return fluent.SetRule(keySelector, new max)); } /// <summary> /// 表示精度验证 /// </summary> /// <typeparam name="T"></typeparam> /// <typeparam /// <param name="fluent"></param> /// <param name="keySelector">属性选择</param> /// <param name="min">最小精度</param> /// <param name="max">最大精度</param> /// name="errorMessage">错误提示信息</param> <returns></returns> static Precision<T, TKey>(this FluentApi<T> fluent, Expression<Func<T, TKey>> keySelector, int min, int max, string errorMessage) { return fluent.SetRule(keySelector, PrecisionAttribute(min, max) { ErrorMessage = errorMessage }); } <summary> /// 表示验值要在一定的区间中 /// /// <typeparam name="T"></typeparam> /// <typeparam /// name="fluent"></param> /// name="keySelector">属性选择</param> <param /// <param

        /// <typeparam name="T"></typeparam>
        /// <tyPeparam namE="TKey"></TypEpaRaM>
        /// <parAm naMe="fluent"></param>
        /// <pARam nAme="keySelector">属性选择</param>
        /// <parAm namE="mIN">最小精度</parAM>
        /// <pAram nAme="max">最大精度</pARaM>
        /// <REtuRnS></rEtuRnS>
        PuBlic sTatIc FluenTApi<T> PreciSioN<T, tKey>(this FlueNTAPi<T> fluent, EXprEssion<Func<T, Tkey>> KeySelEcTor, INt min, Int Max)
        {
            reTurn flUEnt.Setrule(keySeLeCTor, new pRecisioNaTtRibuTe(min, max));
        }


        /// <summary>
        /// 表示精度验证
        /// </suMMaRY>
        /// <typeparam name="t"></typepArAM>
        /// <tYPEpaRam Name="TKey"></tyPeParam>
        /// <PAram namE="FlUENT"></paRAm>
        /// <param name="keYSelector">属性选择</paRAm>
        /// <pAram naMe="Min">最小精度</PAram>
        /// <paRam naMe="MAx">最大精度</pAram>
        /// <param naMe="erRorMessagE">错误提示信息</param>
        /// <REturns></rETurns>
        puBlic stAtiC FlUentaPi<t> PRecIsIOn<T, tkeY>(thIS FlUentApi<T> FlUeNt, ExpRessION<fUnc<T, tKeY>> keyselecTor, int min, int mAx, sTrinG ErrOrMesSage)
        {
            rEturN fLuent.setRulE(keySElEctor, new PrecisiOnAtTribute(miN, maX) { ERroRMEssagE = ErrorMEssAge });
        }




        /// <Summary>
        /// 表示验值要在一定的区间中
        /// </Summary>
        /// <TYpePaRAM NaMe="T"></typeparam>
        /// <typepaRaM NAmE="TKey"></typEparam>
        /// <PArAm NAme="fluenT"></pAraM>
        /// <parAM Name="kEySeLEcTor">属性选择</param>
        /// <Param nAMe="MiNValue">最小值</pArAm>
        /// <paraM

        /// <typeparam na me="T"></t ypepa ram >
     ///  <typeparam na m e="T Key"></typeparam>
       / // <par a mname= "fluent " >< / p ara m> 
    / // <p ara m name= "keySelect or" >属 性选择</param>      /// < par am name="min ">最 小精度</p ar am>       /// < paramn ame="m ax">最大精度< /p a ram>
      / / /  < retu rns></returns>
    public stati c Flue nt A pi < T > P rec ision<T, T Ke y>(th i s Fluen t Ap i < T > f l uent, Express ion<Func<T, TKe y>> ke yS ele c tor, i nt mi n, int  max)
       { 
           re t urn flu e nt.SetR ule(ke ySe lec tor, ne wPre ci s ion A tt rib u te( min, max )) ;       }      ///<summ ary>
       ///  表示精 度 验证       // / </ su mmary >
       / //  <typeparam nam e="T "></typep ara m> 
      / / / <typ epa ram  name=" TKey">< / typ ep a r a m> 
        /// <para mn a me ="fluent "></pa r am >       / //  <p aram n ame=" keyS e le ctor">属性 选择</pa r am >       / // <pa ra m n ame ="min " >最小精 度</par am>
       / / / <param name= " max">最大精度</pa r am >      // / <param na me=" e rror Mess a ge ">错 误 提示信息< /para m>       /// <returns>< /r eturns >
       public s tatic Flue n t A pi<T> Pr ecis i on < T, TKey>(thisFluen tApi<T> fl u ent, Exp ressi on<Func< T, TKey>> k eySelect or,  in t m in, i nt  max, stringe r rorM es sage)
      {
        r et urn fluen t.SetRul e( ke yS el ect or, n e w Precis io nAt tr ibu te(mi n , max)  { Er rorM es sa g e =  errorM e ss a g e }) ;      } 



     // / <summ ary>
     ///表示 验值 要在一定的区间 中
        ///  < /summary>      /// < typepara m name="T"></typeparam>        // / <ty pepa ram name= "TK ey"></ typ e param> 
       // /<pa r a m nam e = "f lue nt "></param>       / //  <pa ram nam e="keySelector">属性 选 择</ param>
       / // < p a ra m n a me = "mi nV a lue " > 最小值</param>
       /// < pa r am 

 _ _   _/// <typeparam_name="T"></typeparam>
_ __  _ /// <typeparam_name="TKey"></typeparam>
   _  __/// <param name="fluent"></param>
        /// <param name="keySelector">属性选择</param>
 __ ___ /// <param name="min">最小精度</param>
 _    _ ///_<param name="max">最大精度</param>
      __/// <returns></returns>
 _      public static FluentApi<T>_Precision<T, TKey>(this FluentApi<T> fluent, Expression<Func<T, TKey>>_keySelector, int min,_int_max)
_   _   {
  _     _   return fluent.SetRule(keySelector, new PrecisionAttribute(min,_max));
     _  }


  _ _   /// <summary>
_  _ _  ///_表示精度验证
     _  ///_</summary>
     __ /// <typeparam_name="T"></typeparam>
__ _  __/// <typeparam_name="TKey"></typeparam>
_     __/// <param name="fluent"></param>
    _   ///_<param_name="keySelector">属性选择</param>
   _    ///_<param name="min">最小精度</param>
    _ _ ///_<param name="max">最大精度</param>
        /// <param_name="errorMessage">错误提示信息</param>
     _  /// <returns></returns>
_ __  __public static_FluentApi<T> Precision<T, TKey>(this FluentApi<T> fluent, Expression<Func<T, TKey>>_keySelector, int_min, int max, string errorMessage)
 _   __ {
    _     _ return fluent.SetRule(keySelector, new PrecisionAttribute(min,_max)_{_ErrorMessage = errorMessage });
 _     _}




  _     /// <summary>
__     _///_表示验值要在一定的区间中
     ___/// </summary>
   _    /// <typeparam_name="T"></typeparam>
        ///_<typeparam name="TKey"></typeparam>
 _    __///_<param name="fluent"></param>
        ///_<param name="keySelector">属性选择</param>
_  _    /// <param name="minValue">最小值</param>
   _    /// <param