EF Core 中實現 動態數據過濾器

 

前言

　　在項目開發中，我們很多時候都會設計  軟刪除、所屬用戶 等等一系列字段 來方便我們在業務查詢的時候進行各種過濾

　　然后引申的問題就是：

　　　　在業務查詢的時候，我們要如何加上這些條件？或者動態禁用某些查詢條件呢？

EF Core自帶的全局過濾查詢功能

　　EF Core提供了一個HasQueryFilter 供我們在查詢的時候進行預置部分篩選條件 

　　例如：

　　    builder.HasQueryFilter(x => !x.IsDelete);

　　這樣查詢的時候  EF Core 會自動幫我們實現過濾

　　然后如果不想使用的時候可以全部忽略      

　　  DbSet.IgnoreQueryFilters();

　　咋一看 很完美  

　　然后我們實際操作的時候

　　1.我是不是每個Entity里面是不是都要配置一次呢？

　　2.我只想禁用部分篩選條件呢？

　　3.我的查詢條件的某些參數要動態呢？

　　　　例如和用戶相關的數據等等

　　　 （有些人可能會說 我想辦法把User的信息注入到DbContext里面不就可以了  假如我還要別的信息呢  還是接着注入？）

　　這就是理論和實踐之間的差距

　　然后再網上找好久，找到了 EntityFramework-Plus  （開源免費）

　　https://github.com/zzzprojects/EntityFramework-Plus

　    官網地址： http://entityframework-plus.net/  

　　內置了很多功能  本篇只針對查詢過濾做說嘛

 

 EntityFramework-Plus 查詢過濾功能

　　1.QueryFilterManager

　　QueryFilterManager 主要用來預設全局過濾

　　例如：

　　QueryFilterManager.Filter<Customer>(q => q.Where(x => x.IsActive));

　　var ctx = new EntitiesContext();

　　QueryFilterManager.InitilizeGlobalFilter(ctx);

　　這樣即可。。。

　　但是需要提前注意的是 QueryFilterManager 預設后是無法更改的

　　無法更改這是在  谷歌的時候  作者正好回復的別人的時候看到的

　　就和我們之前第三點  動態 沖突了

　　然后只能再看別的方式了

　　2.Filter

　　Z.EntityFramework.Plus 提供了 通過DbContext 的擴展方式來進行注入篩選條件的方式

　　例如：

　　var ctx = new EntitiesContext();

　　ctx.Filter<IAnimal>(MyEnum.EnumValue, q => q.Where(x => x.IsDomestic))

　　//禁用指定鍵值查詢條件

　　ctx.Filter(MyEnum.EnumValue).Disable();

　　var dogs = ctx.Dogs.ToList();

　　//啟用指定鍵值查詢條件

　　ctx.Filter(MyEnum.EnumValue).Enable();

　　// SELECT * FROM Dog WHERE IsDomestic = true
　　var dogs = ctx.Dogs.ToList();

　　這樣好像符合我們的需求  

　　3.AsNoFilter

　　禁用條件

　　例如：　

　　var ctx = new EntitiesContext();

　　this.Filter<Customer>(q => q.Where(x => x.IsActive));

　　// SELECT * FROM Customer WHERE IsActive = true
　　var list = ctx.Customers.ToList();

　　// SELECT * FROM Customer
　　var list = ctx.Customers.AsNoFilter().ToList();

 

　　AsNoFilter()后如何啟用  指定查詢條件  作者好像沒有做相應擴展 ，后面會給出對應擴展方法

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

說了這么多 理論補完了   實際操作的時候呢？

　　1.這些條件如何注入進來呢？

　　2.如何可以讓我任意擴展呢？

  　  3.假如我們操作時通過倉儲 ，而不是  直接通過DbContext 呢？

 

 

如何封裝

 這邊演示通過我自己的開源項目做為事例：

　　github  : https://github.com/wulaiwei/WorkData.Core

　　主要依賴的框架

　　1.AutoFac

　　2.EF Core

　　3.Z.EntityFramework.Plus

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

　　對於我們來說 我們無論使用多少個數據篩選器  返回的都應該是同一個返回值  ，我們去看 DbContext.Filter(....)  會發現他的返回值都是 BaseQueryFilter

　　針對這個  我們可以得到兩條信息  我們需要 傳入 DbContext  和 一個返回值為  BaseQueryFilter  的方法

　　所以 我們定義如下接口 IDynamicFilter

    public interface IDynamicFilter
    {
        BaseQueryFilter InitFilter(DbContext dbContext);
    }

　　這樣我們這邊就得到了一個標准

　　例如 我們我們需要一個 所屬用戶和  軟刪除 的數據篩選器   我們只需要繼承他即可

　　我們如何區分他們呢？

　　我們在之前使用 Z.EntityFramework.Plus  是看到了  可以設置篩選器的Key

　　所以 我們也同樣擴展個屬性 DynamicFilterAttribute  來作為他們的名字

    public class DynamicFilterAttribute: Attribute
    {
        /// <summary>
        /// Name
        /// </summary>
        public string Name { get; set; }

    }

　　然后我們定義我們的  所屬用戶和  軟刪除 的數據篩選器  並為他們設置名稱

　　CreateDynamicFilter

 /// <summary>
    /// CreateDynamicFilter
    /// </summary>
    [DynamicFilter(Name = "CreateUserId")]
    public class CreateDynamicFilter : IDynamicFilter
    {
        /// <summary>
        /// InitFilter
        /// </summary>
        /// <param name="dbContext"></param>
        /// <returns></returns>
        public BaseQueryFilter InitFilter(DbContext dbContext)
        {
            var workdataSession = IocManager.Instance.Resolve<IWorkDataSession>();
            if (workdataSession == null)
                return dbContext
                    .Filter<ICreate>("CreateUserId", x => x.Where(w => w.CreateUserId == string.Empty ));

            return dbContext
                .Filter<ICreate>("CreateUserId", x => x.Where(w => w.CreateUserId == workdataSession.UserId || w.CreateUserId == ""));
        }
    }

　　說明：

　　var workdataSession = IocManager.Instance.Resolve<IWorkDataSession>();

　　用來獲取你所需要的 傳參 

   　 IocManager.Instance.Resolve  是WorkData  關於Ioc的封裝  源碼可以參見git  或者上一篇博客

　　SoftDeleteDynamicFilter

/// <summary>
    /// SoftDeleteDynamicFilter
    /// </summary>
    [DynamicFilter(Name = "SoftDelete")]
    public class SoftDeleteDynamicFilter: IDynamicFilter
    {
        public BaseQueryFilter InitFilter(DbContext dbContext)
        {
            return dbContext
                .Filter<IsSoftDelete>("SoftDelete", x => x.Where(w => !w.IsDelete));
        }
    }

　　 這樣 我們所有接口 和實現定義好了 如何管理呢？

　　1.將繼承 IDynamicFilter 的注入到Ioc里面

            #region 動態審計注入
            var filterTypes = _typeFinder.FindClassesOfType<IDynamicFilter>();

            foreach (var filterType in filterTypes)
            {
                var dynamicFilterAttribute = filterType.GetCustomAttribute(typeof(DynamicFilterAttribute)) as DynamicFilterAttribute;
                if (dynamicFilterAttribute == null)
                    continue;

                builder.RegisterType(filterType).Named<IDynamicFilter>(dynamicFilterAttribute.Name);
            }
            #endregion

　　說明：

　　1.ITypeFinder　是從 nopcommerce 抽離出來的反射方法   已集成到WorkData  百度即可查詢到相應說明文檔

　　2.通過 GetCustomAttribute  獲取 DynamicFilterAttribute 的屬性名稱  作為注冊到Ioc名稱

　　2.如何設置一個啟用數據篩選器呢？我們這邊定義個配置文件  通過 .net core 提供的程序進行配置文件注入

    /// <summary>
    /// 動態攔截器配置
    /// </summary>
    public class DynamicFilterConfig
    {
        public List<string> DynamicFilterList{ get; set; }
    }

"DynamicFilterConfig": {

"DynamicFilterList": [ "CreateUserId", "SoftDelete" ]
}

 

如何注入配置文件 可以通過百度或者查看workdata源碼 即可 這不做說明

　　3.如何管理呢？什么時候統一添加到 DbContext呢？

　　我們這邊定義一個DynamicFilterManager 提供一個 字典集合 來暫存所以的 IDynamicFilter，同時提供一個方法來進行初始化值

    public static class DynamicFilterManager
    {
        static DynamicFilterManager()
        {
            CacheGenericDynamicFilter = new Dictionary<string, IDynamicFilter>();
        }

        /// <summary>
        ///     CacheGenericDynamicFilter
        /// </summary>
        public static Dictionary<string, IDynamicFilter> CacheGenericDynamicFilter { get; set; }

        /// <summary>
        ///     AddDynamicFilter
        /// </summary>
        /// <param name="dbContext"></param>
        /// <returns></returns>
        public static void AddDynamicFilter(this DbContext dbContext)
        {
            if (dbContext == null) return;
            foreach (var dynamicFilter in CacheGenericDynamicFilter) dynamicFilter.Value.InitFilter(dbContext);
        }

        /// <summary>
        ///     AsWorkDataNoFilter
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="query"></param>
        /// <param name="context"></param>
        /// <param name="filterStrings"></param>
        /// <returns></returns>
        public static IQueryable<T> AsWorkDataNoFilter<T>(this DbSet<T> query, DbContext context,
            params object[] filterStrings) where T : class
        {
            var asNoFilterQueryable = query.AsNoFilter();

            object query1 = asNoFilterQueryable;
            var items = CacheGenericDynamicFilter.Where(x => filterStrings.Contains(x.Key));

            query1 = items.Select(key => context.Filter(key.Key)).Where(item => item != null)
                .Aggregate(query1, (current, item) => (IQueryable) item.ApplyFilter<T>(current));
            return (IQueryable<T>) query1;
        }

        /// <summary>
        ///     SetCacheGenericDynamicFilter
        /// </summary>
        public static void SetCacheGenericDynamicFilter()
        {
            var dynamicFilterConfig = IocManager.Instance.ResolveServiceValue<DynamicFilterConfig>();

            foreach (var item in dynamicFilterConfig.DynamicFilterList)
            {
                var dynamicFilter = IocManager.Instance.ResolveName<IDynamicFilter>(item);
                CacheGenericDynamicFilter.Add(item, dynamicFilter);
            }
        }
    }

　　然后我們在DbContext里面的 OnModelCreating 進行初始化

 /// <summary>
        ///     重寫模型創建函數
        /// </summary>
        /// <param name="modelBuilder"></param>
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            //初始化對象
            DynamicFilterManager.SetCacheGenericDynamicFilter();
        }

　　初始化完成后如何將條件付給  DbContext 呢？

　　在DynamicFilterManager 中我們提供了一個擴展方法 AddDynamicFilter 你可以在你創建 DbContext 的時候調用

     /// <summary>
        ///     AddDynamicFilter
        /// </summary>
        /// <param name="dbContext"></param>
        /// <returns></returns>
        public static void AddDynamicFilter(this DbContext dbContext)
        {
            if (dbContext == null) return;
            foreach (var dynamicFilter in CacheGenericDynamicFilter) dynamicFilter.Value.InitFilter(dbContext);
        }

　　在WorkData中  我們則需要在EfContextFactory 進行調用

　　dbContext = _resolver.Resolve<TDbContext>();

　　//初始化攔截器
　　dbContext.AddDynamicFilter();

  /// <summary>
    ///     EfContextFactory
    /// </summary>
    public class EfContextFactory : IEfContextFactory
    {
        private readonly IResolver _resolver;

        public EfContextFactory(IResolver resolver)
        {
            _resolver = resolver;
        }

        /// <summary>
        ///     default current context
        /// </summary>
        /// <param name="dic"></param>
        /// <param name="tranDic"></param>
        /// <returns></returns>
        public TDbContext GetCurrentDbContext<TDbContext>(Dictionary<string, DbContext> dic, Dictionary<DbContext, IDbContextTransaction> tranDic)
            where TDbContext : DbContext
        {
            return GetCurrentDbContext<TDbContext>(dic, tranDic, string.Empty);
        }

        /// <summary>
        ///GetCurrentDbContext
        /// </summary>
        /// <typeparam name="TDbContext"></typeparam>
        /// <param name="dic"></param>
        /// <param name="tranDic"></param>
        /// <param name="conString"></param>
        /// <returns></returns>
        public TDbContext GetCurrentDbContext<TDbContext>(Dictionary<string, DbContext> dic, Dictionary<DbContext, IDbContextTransaction> tranDic, string conString)
            where TDbContext : DbContext
        {
            conString = typeof(TDbContext).ToString();
            var dbContext = dic.ContainsKey(conString + "DbContext") ? dic[conString + "DbContext"] : null;
            try
            {
                if (dbContext != null)
                {
                    return (TDbContext)dbContext;
                }
            }
            catch (Exception)
            {
                dic.Remove(conString + "DbContext");
            }
            dbContext = _resolver.Resolve<TDbContext>();

            //初始化攔截器
            dbContext.AddDynamicFilter();

            //我們在創建一個，放到數據槽中去
            dic.Add(conString + "DbContext", dbContext);

            //開始事務
            var tran = dbContext.Database.BeginTransaction();
            tranDic.Add(dbContext, tran);

            return (TDbContext)dbContext;
        }
    }

　　這樣我們的篩選器已經全部注入完成了

　　還剩下一個我們之前說的  

　　AsNoFilter()后如何啟用  指定查詢條件  作者好像沒有做相應擴展 ，后面會給出對應擴展方法

　　通過查看源碼后 

    /// <summary>
    ///     Filter the query using context filters associated with specified keys.
    /// </summary>
    /// <typeparam name="T">The type of elements of the query.</typeparam>
    /// <param name="query">The query to filter using context filters associated with specified keys.</param>
    /// <param name="keys">
    ///     A variable-length parameters list containing keys associated to context filters to use to filter the
    ///     query.
    /// </param>
    /// <returns>The query filtered using context filters associated with specified keys.</returns>
    public static IQueryable<T> Filter<T>(this DbSet<T> query, params object[] keys) where T : class
    {
      BaseQueryFilterQueryable filterQueryable = QueryFilterManager.GetFilterQueryable((IQueryable) query);
      IQueryable<T> query1 = filterQueryable != null ? (IQueryable<T>) filterQueryable.OriginalQuery : (IQueryable<T>) query;
      return QueryFilterManager.AddOrGetFilterContext(filterQueryable != null ? filterQueryable.Context : InternalExtensions.GetDbContext<T>(query)).ApplyFilter<T>(query1, keys);
    }

  Z.EntityFramework.Plus  提供了一個 ApplyFilter  所以 我們基於這個 做個擴展

  /// <summary>
        ///     AsWorkDataNoFilter
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="query"></param>
        /// <param name="context"></param>
        /// <param name="filterStrings"></param>
        /// <returns></returns>
        public static IQueryable<T> AsWorkDataNoFilter<T>(this DbSet<T> query, DbContext context,
            params object[] filterStrings) where T : class
        {
            var asNoFilterQueryable = query.AsNoFilter();

            object query1 = asNoFilterQueryable;
            var items = CacheGenericDynamicFilter.Where(x => filterStrings.Contains(x.Key));

            query1 = items.Select(key => context.Filter(key.Key)).Where(item => item != null)
                .Aggregate(query1, (current, item) => (IQueryable) item.ApplyFilter<T>(current));
            return (IQueryable<T>) query1;
        }

這樣 我們可以傳入指定的篩選器名稱  啟用自己想要的

最終我們的倉儲就變成了這樣：

 /// <summary>
    ///     EfBaseRepository
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    /// <typeparam name="TPrimaryKey"></typeparam>
    /// <typeparam name="TDbContext"></typeparam>
    public class EfBaseRepository<TDbContext, TEntity, TPrimaryKey> :
        BaseRepository<TEntity, TPrimaryKey>,
        IRepositoryDbConntext where TEntity : class, IAggregateRoot, IEntity<TPrimaryKey>
        where TDbContext : DbContext
    {
        //public IQueryable<EntityType> EntityTypes => Context.Model.EntityTypes.Where(t => t.Something == true);

        private readonly IDbContextProvider<TDbContext> _dbContextProvider;
        private readonly IPredicateGroup<TEntity> _predicateGroup;

        public EfBaseRepository(
            IDbContextProvider<TDbContext> dbContextProvider,
            IPredicateGroup<TEntity> predicateGroup)
        {
            _dbContextProvider = dbContextProvider;
            _predicateGroup = predicateGroup;
        }

        /// <summary>
        ///     Gets EF DbContext object.
        /// </summary>
        public TDbContext Context => _dbContextProvider.GetContent();

        /// <summary>
        ///     Gets DbSet for given entity.
        /// </summary>
        public virtual DbSet<TEntity> DbSet => Context.Set<TEntity>();

        #region DbContext

        /// <summary>
        ///     GetDbContext
        /// </summary>
        /// <returns></returns>
        public DbContext GetDbContext()
        {
            return Context;
        }

        #endregion

        #region Query



        /// <summary>
        ///     FindBy
        /// </summary>
        /// <param name="primaryKey"></param>
        /// <returns></returns>
        public override TEntity FindBy(TPrimaryKey primaryKey)
        {
            var entity = DbSet.Find(primaryKey);
            return entity;
        }

        /// <summary>
        /// FindBy
        /// </summary>
        /// <param name="primaryKey"></param>
        /// <param name="includeNames"></param>
        /// <returns></returns>
        public override TEntity FindBy(TPrimaryKey primaryKey, string[] includeNames)
        {
            var query = DbSet;
            foreach (var includeName in includeNames)
            {
                query.Include(includeName);
            }
            var entity = query.Find(primaryKey);
            return entity;
        }

        /// <summary>
        ///     AsNoFilterFindBy
        /// </summary>
        /// <param name="primaryKey"></param>
        /// <returns></returns>
        public override TEntity AsNoFilterFindBy(TPrimaryKey primaryKey)
        {
            var entity = DbSet.AsNoFilter()
                .SingleOrDefault(x => x.Id.Equals(primaryKey));
            return entity;
        }

        /// <summary>
        /// AsNoFilterFindBy
        /// </summary>
        /// <param name="primaryKey"></param>
        /// <param name="includeNames"></param>
        /// <returns></returns>
        public override TEntity AsNoFilterFindBy(TPrimaryKey primaryKey, string[] includeNames)
        {

            var query = DbSet.AsNoFilter();
            foreach (var includeName in includeNames)
            {
                query.Include(includeName);
            }
            var entity = query.SingleOrDefault(x => x.Id.Equals(primaryKey));

            return entity;
        }


        /// <summary>
        ///     FindBy
        /// </summary>
        /// <param name="primaryKey"></param>
        /// <param name="filterStrings"></param>
        /// <returns></returns>
        public override TEntity FindBy(TPrimaryKey primaryKey, params object[] filterStrings)
        {
            var entity = DbSet.AsWorkDataNoFilter(Context, filterStrings)
                .SingleOrDefault(x => x.Id.Equals(primaryKey));
            return entity;
        }

        /// <summary>
        /// FindBy
        /// </summary>
        /// <param name="primaryKey"></param>
        /// <param name="includeNames"></param>
        /// <param name="filterStrings"></param>
        /// <returns></returns>
        public override TEntity FindBy(TPrimaryKey primaryKey, string[] includeNames, params object[] filterStrings)
        {
            var query = DbSet.AsWorkDataNoFilter(Context, filterStrings);
            foreach (var includeName in includeNames)
            {
                query.Include(includeName);
            }
            var entity = query.SingleOrDefault(x => x.Id.Equals(primaryKey));

            return entity;
        }


        /// <summary>
        ///     GetAll
        /// </summary>
        /// <returns></returns>
        public override IQueryable<TEntity> GetAll()
        {
            return DbSet;
        }


        /// <summary>
        /// GetAll
        /// </summary>
        /// <param name="includeNames"></param>
        /// <returns></returns>
        public override IQueryable<TEntity> GetAll(string[] includeNames)
        {
            var query = DbSet;
            foreach (var includeName in includeNames)
            {
                query.Include(includeName);
            }
            return query;
        }

        /// <summary>
        /// GetAll
        /// </summary>
        /// <param name="filterStrings"></param>
        /// <returns></returns>
        public override IQueryable<TEntity> GetAll(params object[] filterStrings)
        {
            return DbSet.AsWorkDataNoFilter(Context, filterStrings);
        }

        /// <summary>
        /// GetAll
        /// </summary>
        /// <param name="includeNames"></param>
        /// <param name="filterStrings"></param>
        /// <returns></returns>
        public override IQueryable<TEntity> GetAll(string[] includeNames, params object[] filterStrings)
        {
            var query = DbSet.AsWorkDataNoFilter(Context, filterStrings);

            foreach (var includeName in includeNames)
            {
                query.Include(includeName);
            }
            return query;
        }

        /// <summary>
        /// AsNoFilterGetAll
        /// </summary>
        /// <returns></returns>
        public override IQueryable<TEntity> AsNoFilterGetAll()
        {
            return DbSet.AsNoFilter();
        }

        /// <summary>
        /// AsNoFilterGetAll
        /// </summary>
        /// <param name="includeNames"></param>
        /// <returns></returns>
        public override IQueryable<TEntity> AsNoFilterGetAll(string[] includeNames)
        {
            var query = DbSet.AsNoFilter();

            foreach (var includeName in includeNames)
            {
                query.Include(includeName);
            }
            return query;
        }
        #endregion

        #region Insert

        /// <summary>
        ///     Insert
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="model"></param>
        public override TEntity Insert(TEntity model)
        {
            return DbSet.Add(model).Entity;
        }

        /// <summary>
        ///     InsertGetId
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public override TPrimaryKey InsertGetId(TEntity model)
        {
            model = Insert(model);

            Context.SaveChanges();

            return model.Id;
        }

        /// <summary>
        ///     Insert
        /// </summary>
        /// <param name="entities"></param>
        public override void Insert(IEnumerable<TEntity> entities)
        {
            if (entities == null)
                throw new ArgumentNullException(nameof(entities));

            DbSet.AddRange(entities);

            Context.SaveChanges();
        }

        #endregion

        #region Delete

        /// <summary>
        ///     Delete
        /// </summary>
        /// <param name="entity"></param>
        public override void Delete(TEntity entity)
        {
            DbSet.Remove(entity);
            Context.SaveChanges();
        }

        /// <summary>
        ///     Delete
        /// </summary>
        /// <param name="entities"></param>
        public override void Delete(IEnumerable<TEntity> entities)
        {
            if (entities == null)
                throw new ArgumentNullException(nameof(entities));

            DbSet.RemoveRange(entities);

            Context.SaveChanges();
        }

        #endregion

        #region Update

        /// <summary>
        ///     Update
        /// </summary>
        /// <param name="entity"></param>
        public override void Update(TEntity entity)
        {
            DbSet.Update(entity);
            Context.SaveChanges();
        }

        /// <summary>
        ///     Update
        /// </summary>
        /// <param name="entities"></param>
        public override void Update(IEnumerable<TEntity> entities)
        {
            if (entities == null)
                throw new ArgumentNullException(nameof(entities));

            DbSet.UpdateRange(entities);

            Context.SaveChanges();
        }

        #endregion
    }

  說明：倉儲的設計理念是從  ABP中抽離出來的 

  最后附測試  

啟用的篩選器為 "CreateUserId", "SoftDelete"

 /// <summary>
        ///     Index
        /// </summary>
        /// <returns></returns>
        public IActionResult Index()
        {
            _baseRepository.GetAll().ToList();
            _baseRepository.GetAll("CreateUserId","xxx假定不存在的篩選器").ToList();
            _baseRepository.AsNoFilterGetAll().ToList();

            _baseRepository.FindBy("1");
            _baseRepository.FindBy("1", "CreateUserId", "xxx假定不存在的篩選器");
            _baseRepository.AsNoFilterFindBy("1");
            return View();
        }