EF 基本数据过滤

没猜错的话, 你们一定会和一大堆查询条件过不去, 重复的写,反复的写, 写到山崩地裂.

今天看了园友的文字:
实体框架高级应用之动态过滤 EntityFramework DynamicFilters

我把我的处理方式给大家分享一下.

查询条件可以是这样的,有很多:

也可以是这样的, 没有几个:

我数了一下,我们系统里的Controller , 112个, 68个查询条件.

如果把这 68个查询条件转换为查询代码的话, 想想都蛋疼啊, 那得写多少啊.

比如这样, 重复,机械,没有营养:

         public IEnumerable<CREDIT_ASSESS_RESULT> GetCreditResults(CreditAssessResultCondition condition)
         {
             using (var db = new Entities())
             {
                 IQueryable<CREDIT_ASSESS_RESULT> query = db.CREDIT_ASSESS_RESULT.Where(q => q.STATUS >= );
                 )
                 {
                     query = query.Where(q => q.CARRIER_ID == condition.CARRIER_ID);
                 }

                 )
                 {
                     query = query.Where(q => q.LOCAL_COMPANY_ID == condition.COMPANY_ID);
                 }

                 if (condition.ROUTE_ID.HasValue)
                 {
                     query = query.Where(q => q.APPLYTO_ROUTEID == condition.ROUTE_ID);
                 }

                 if (condition.CUSTOMER_TYPE.HasValue)
                 {
                     query = query.Where(q => q.APPLYTO_CUSTOMER == condition.CUSTOMER_TYPE);
                 }

                 if (condition.CREDIT_PERIOD.HasValue)
                 {
                     //String period = condition.CREDIT_PERIOD.Value.ToString();
                     query = query.Where(q => q.PERIOD == (int)condition.CREDIT_PERIOD.Value);
                 }

                 if (condition.CREDIT_YEAR.HasValue)
                 {
                     query = query.Where(q => q.YEARS.Value == condition.CREDIT_YEAR.Value);
                 }

                 )
                 {
                     query = query.Where(q => q.MONTHS == condition.CREDIT_MONTH);
                 }
                 )
                 {
                     query = query.Where(q => q.SEASONS == condition.CREDIT_SEASON);
                 }

                 if (!String.IsNullOrWhiteSpace(condition.CUSTOMER_CODE))
                 {
                     query = query.Where(q => q.COMPANY_ID == condition.CUSTOMER_ID && (q.COMPANY_NAME_CN.ToUpper().Contains(condition.CUSTOMER_CODE.ToUpper()) ||
                         q.COMPANY_NAME_EN.ToUpper().Contains(condition.CUSTOMER_CODE.ToUpper())));
                 }

                 if (condition.CustomerSearch.HasValue && condition.CustomerSearch.Value)
                 {
                     query = query.Where(q => q.STATUS > );
                 }

                 return query.OrderByDescending(q => q.CREATE_DATETIME).ThenBy(q => q.APPLYTO_COMPANY).ThenBy(q => q.COMPANY_NAME_EN).DoPage(condition.Pager).ToList();
             }
         }

为了解放同志们, 我借助 DynamicLinq  写了个简单的解决方案:

1, 先看查询条件的写法:

     public class RateSearchCondition : BaseQuery<RATES> {

         public decimal? Carrier {
             get;
             set;
         }

         [MapTo("ROUTE_CODE", IgnoreCase = true)]
         public string Route {
             get;
             set;
         }

         [MapTo("POL_CODE", IgnoreCase = true)]
         public string Pol {
             get;
             set;
         }

         [MapTo("POD_CODE", IgnoreCase = true)]
         public string Pod {
             get;
             set;
         }

         /// <summary>
         /// 启运地
         /// </summary>
         [MapTo("FRONT_CODE")]
         public string OrginCode {
             get;
             set;
         }

         /// <summary>
         /// 目的地
         /// </summary>
         [MapTo("PFD_CODE")]
         public string DestCode {
             get;
             set;
         }

         [MapTo("EFFECTIVE_DATE")]
         public DateTime? EffectiveDate {
             get;
             set;
         }

         [MapTo("EXPIRATION_DATE")]
         public DateTime? ExpirationDate {
             get;
             set;
         }

         public Status? StatusEnum {
             get;
             set;
         }

         [MapTo("STATUS")]
         public decimal? StatusValue {
             get {
                 return (decimal?)this.StatusEnum;
             }
         }

         [MapTo("SCHEDULE_ID")]
         public decimal? ScheduleID {
             get;
             set;
         }

         public string Vessel {
             get;
             set;
         }

         public string Voyage {
             get;
             set;
         }

         /// <summary>
         /// 销售公司
         /// </summary>
         public decimal? Company {
             get;
             set;
         }

         public enum Status {
             [Description("作废")]
             Invalid = -,
             [Description("草稿")]
             Draft = ,
             [Description("已发布")]
             Published = ,
             [Description("历史")]
             History = ,
         }

         public string VesselName {
             get;
             set;
         }

         public bool IncludeHistory {
             get;
             set;
         }

         [MapTo("RATE_NO", IgnoreCase = true)]
         public string RateNo {
             get;
             set;
         }
     }

简单的类定义而已, 只不过某些属性上加了  MapToAttribute 特性, 有些没有加.

这些加上了 MapTo 的, 就是本文说的.

2, 看一下查询的写法:

         public IEnumerable<RATES> Search(RateSearchCondition cond) {
             using (var db = new Entities()) {
                 var query = cond.Filter(db.RATES.Where(r => !r.DELETE_MARK));

                 if (!(cond.IncludeHistory || cond.StatusEnum == RateSearchCondition.Status.History)) {
                     query = query.Where(m => m.STATUS != (int)RateSearchCondition.Status.History)
                         .OrderByDescending(r => r.MODIFY_DATETIME);
                 } else
                     query = query.OrderByDescending(r => r.CREATEBY ?? );

                 return query
                     .DoPage(cond.Pager)
                     .ToList();
             }
         }

这样看, 代码是不是清爽很多?

那么多查询条件, 基本都浓缩进了 cond.Filter(...) 中了, 如果要加其它的查询条件, 只需要改一下查询条件的类, 并加上 MapTo 就可以了.

不能浓缩进去的, 直接写在代码里, 反正也没有几个.

3, 看一下 MapTo 的定义:

     /// <summary>
     /// 用于 BaseQuery
     /// </summary>
     [AttributeUsage(AttributeTargets.Property)]
     public class MapToAttribute : Attribute {

         /// <summary>
         /// 映射到的属性
         /// </summary>
         public string Field {
             get;
             set;
         }

         /// <summary>
         /// 比较类型
         /// </summary>
         public MapToOpts Opt {
             get;
             set;
         }

         /// <summary>
         /// 是否忽略大小写
         /// </summary>
         public bool IgnoreCase {
             get;
             set;
         }

         /// <summary>
         ///
         /// </summary>
         /// <param name="field"></param>
         public MapToAttribute(string field) {
             if (string.IsNullOrEmpty(field))
                 throw new ArgumentNullException("field");

             this.Field = field;
         }

     }

     /// <summary>
     /// 比较类型
     /// </summary>
     public enum MapToOpts {
         /// <summary>
         /// 等于
         /// </summary>
         Equal,

         /// <summary>
         /// 不等于
         /// </summary>
         NotEqual,

         /// <summary>
         /// 大于
         /// </summary>
         Gt,

         /// <summary>
         /// 大于等于
         /// </summary>
         GtOrEqual,

         /// <summary>
         /// 小于
         /// </summary>
         Lt,

         /// <summary>
         /// 小于等
         /// </summary>
         LtOrEqual,

         /// <summary>
         /// 以 XXX 开始(字符串)
         /// </summary>
         StartWith,

         /// <summary>
         /// 以XXX结尾(字符串)
         /// </summary>
         EndWith,

         /// <summary>
         /// 包含XXX(字符串)
         /// </summary>
         Include
     }

从 MapToOpts 可以看出, 基本的大于,小于,等于,不等于, 开始,包含,结束这样的查询条件都可以涵盖到.

但是像 是否包含在集合中 / And / Or 操作是不支持的,  它们需要写在查询方法里, 所以标题我就写的是: 基本数据过滤

4, BaseQuery 的定义:

     [Serializable]
     public class BaseQuery {

         private Pager pager = null;
         public Pager Pager {
             get {
                 if (this.pager == null)
                     this.pager = new Pager();
                 return this.pager;
             }
             set {
                 this.pager = value;
             }
         }

         private bool allowPage = true;
         /// <summary>
         /// 是否分页
         /// </summary>
         [DisableBinding]
         public bool AllowPage {
             get {
                 return this.allowPage;
             }
             set {
                 this.allowPage = value;
             }
         }
     }

     [Serializable]
     public class BaseQuery<T> : BaseQuery where T : class {

         public IQueryable<T> Filter(IQueryable<T> source) {
             var ps = this.GetType()
                 .GetProperties()
                 .ToList();

             ps.ForEach(p => {
                 var mapTo = p.GetCustomAttribute<MapToAttribute>();
                 if (mapTo != null) {
                     var st = typeof(T).GetProperty(mapTo.Field);
                     if (st != null) {
                         var opt = string.Empty;
                         switch (mapTo.Opt) {
                             case MapToOpts.Equal:
                                 opt = "==";
                                 break;
                             case MapToOpts.NotEqual:
                                 opt = "!=";
                                 break;
                             case MapToOpts.Gt:
                                 opt = ">";
                                 break;
                             case MapToOpts.Lt:
                                 opt = "<";
                                 break;
                             case MapToOpts.GtOrEqual:
                                 opt = ">=";
                                 break;
                             case MapToOpts.LtOrEqual:
                                 opt = "<=";
                                 break;
                         }

                         if (!string.IsNullOrEmpty(opt)) {
                             var v = p.GetValue(this);
                             if (v != null) {
                                 string cond = "";
                                 if (v.GetType() == typeof(string) && mapTo.Opt == MapToOpts.Equal && mapTo.IgnoreCase) {
                                     if (!string.IsNullOrWhiteSpace(v.ToString()))
                                     {
                                         cond = string.Format("{0}.ToUpper() {1} @0", st.Name, opt);
                                         source = source.Where(cond, ((string)v).ToUpper());
                                     }
                                 } else {
                                     cond = string.Format("{0} {1} @0", st.Name, opt);
                                     source = source.Where(cond, v);
                                 }

                             }
                         } else {
                             var cond = string.Empty;

                             var v = (string)p.GetValue(this);
                             if (v == null || string.IsNullOrEmpty((string)v))
                                 return;

                             v = v.Replace("\"", "");

                             if (string.IsNullOrEmpty(v))
                                 return;

                             var ignoreCaseStr = mapTo.IgnoreCase ? ".ToUpper()" : "";
                             if (mapTo.IgnoreCase)
                                 v = v.ToUpper();

                             switch (mapTo.Opt) {
                                 case MapToOpts.Include:
                                     cond = string.Format("{0}{1}.IndexOf(\"{2}\") != -1", st.Name, ignoreCaseStr, v);
                                     break;
                                 case MapToOpts.StartWith:
                                     cond = string.Format("{0}{1}.StartsWith(\"{2}\")", st.Name, ignoreCaseStr, v);
                                     break;
                                 case MapToOpts.EndWith:
                                     cond = string.Format("{0}{1}.EndsWith(\"{2}\")", st.Name, ignoreCaseStr, v);
                                     break;
                             }

                             if (!string.IsNullOrEmpty(cond)) {
                                 source = source.Where(cond);
                             }

                         }
                     }
                 }
             });

             return source;
         }
     }

Filter 方法先获取泛型参数的所有 Property, 然后遍例, 获取加到 Property 上的 MapToAttribute 进行相关的操作.

如果某个条件的值是 null , 说明这个条件跳过.

如果是字符类型的条件, 会跟据是否 IgnoreCase 应用 ToUpper , 因为我们用的是 ORACLE 数据, 大小写敏感. 还会应用 IndexOf, StartsWith, EndsWidth

----------------------------

好啦 , 就这样.