EF操作扩展之async

EF的操作类网上很多类，我只是把我在平时项目中的类进行一些改进和扩展，扩展了部分同步和异步的EF操作

接口

 /// <summary>
     /// 接口数据操作基础类
     /// </summary>
     /// <typeparam name="Key"></typeparam>
     /// <typeparam name="Entity"></typeparam>
     public interface IBaseOpertion<TEntity, TKey> where TEntity : class
     {
         /// <summary>
         ///  添加数据
         /// </summary>
         /// <param name="tableName"></param>
         /// <param name="table"></param>
         /// <returns></returns>
         int AddTable(string tableName, DataTable table);
         Task<int> AddTableAsy(string tableName, DataTable table);
         /// <summary>
         /// 添加
         /// </summary>
         /// <param name="entity"></param>
         /// <returns></returns>
         TEntity AddEntity(TEntity entity);
         Task<TEntity> AddEntityAsy(TEntity entity);
         /// <summary>
         ///  批量添加
         /// </summary>
         /// <param name="list"></param>
         /// <returns></returns>
         int AddEntity(List<TEntity> list);
         Task<int> AddEntityAys(List<TEntity> list);
         /// <summary>
         /// 修改
         /// </summary>
         /// <param name="entity"></param>
         /// <returns></returns>
         TEntity UpdateEntity(TEntity entity);
         Task<TEntity> UpdateEntityAsy(TEntity entity);
         /// <summary>
         /// 删除 实体
         /// </summary>
         /// <param name="TEntity"></param>
         /// <returns></returns>
         int DelEntity(TEntity entity);
         Task<int> DelEntityAsy(TEntity entity);
         // <summary>
         /// 删除  主键
         /// </summary>
         /// <param name="TEntity"></param>
         /// <returns></returns>
         int DelEntity(TKey key);
         Task<int> DelEntityAsy(TKey key);
         // <summary>
         /// 删除  条件
         /// </summary>
         /// <param name="TEntity"></param>
         /// <returns></returns>
         int DelEntity(Dictionary<string,object> where);
         Task<int> DelEntityAsy(Dictionary<string, object> where);

         /// <summary>
         /// 根据ID进行查询
         /// </summary>
         /// <param name="key"></param>
         /// <returns></returns>
         TEntity GetEntityByID(TKey key);
         Task<TEntity> GetEntityByIDAsy(TKey key);
         /// <summary>
         /// 根据sql进行查询
         /// </summary>
         /// <param name="predicate"></param>
         /// <returns></returns>
         List<TEntity> GetEntityQuerySql(string sql);
         Task<List<TEntity>> GetEntityQuerySqlAsy(string sql);
         /// <summary>
         /// 根据条件进行查询
         /// </summary>
         /// <param name="fun"></param>
         /// <returns></returns>
         List<TEntity> GetEntityLisrByWhere(Expression<Func<TEntity, bool>> fun);
         Task<List<TEntity>> GetEntityLisrByWhereAsy(Expression<Func<TEntity, bool>> fun);

         /// <summary>
         /// 根据条件进行查询
         /// </summary>
         /// <param name="fun"></param>
         /// <returns></returns>
         TEntity GetEntityByWhere(Expression<Func<TEntity, bool>> fun);
         Task<TEntity> GetEntityByWhereAsy(Expression<Func<TEntity, bool>> fun);
     }

实现类

 /// <summary>
     /// 数据实体操作
     /// </summary>
     /// <typeparam name="TEntity"></typeparam>
     /// <typeparam name="TKey"></typeparam>
     public abstract class BaseService<TEntity, TKey> : IBaseOpertion<TEntity, TKey> where TEntity : class
     {
         public virtual TEntity AddEntity(TEntity entity)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 TEntity newEntity = dbHelper.Set<TEntity>().Add(entity);
                 if (dbHelper.SaveChanges() > )
                     return newEntity;
                 return null;
             }
         }
         public virtual async Task<TEntity> AddEntityAsy(TEntity entity) {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 TEntity newEntity = dbHelper.Set<TEntity>().Add(entity);
                 int temp =await dbHelper.SaveChangesAsync();
                 if (temp > )
                     return newEntity;
                 return null;
             }
         }

         public virtual TEntity UpdateEntity(TEntity entity)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 DbSet<TEntity> dbSet = dbHelper.Set<TEntity>();
                 DbEntityEntry<TEntity> entry = dbHelper.Entry<TEntity>(entity);
                 if (entry.State == System.Data.Entity.EntityState.Detached)
                 {
                     dbSet.Attach(entity);
                     entry.State = System.Data.Entity.EntityState.Modified;
                 }
                 if (dbHelper.SaveChanges() >= )
                     return entity;
                 return null;
             }
         }
         public virtual async Task<TEntity> UpdateEntityAsy(TEntity entity)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 DbSet<TEntity> dbSet = dbHelper.Set<TEntity>();
                 DbEntityEntry<TEntity> entry = dbHelper.Entry<TEntity>(entity);
                 if (entry.State == System.Data.Entity.EntityState.Detached)
                 {
                     dbSet.Attach(entity);
                     entry.State = System.Data.Entity.EntityState.Modified;
                 }
                 int result = await dbHelper.SaveChangesAsync();
                 if (result >= )
                     return entity;
                 return null;
             }
         }

         public virtual int DelEntity(TEntity entity)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 dbHelper.Set<TEntity>().Remove(entity);
                 return dbHelper.SaveChanges();
             }
         }
         public virtual async Task<int> DelEntityAsy(TEntity entity)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 dbHelper.Set<TEntity>().Remove(entity);
                 return await dbHelper.SaveChangesAsync();
             }
         }

         public virtual TEntity GetEntityByID(TKey key)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 var entity = dbHelper.Set<TEntity>().Find(key);
                 return entity;
             }
         }
         public virtual async Task<TEntity> GetEntityByIDAsy(TKey key)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 return await dbHelper.Set<TEntity>().FindAsync(key);
             }
         }

         public virtual List<TEntity> GetEntityQuerySql(string sql)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 var entity = dbHelper.Set<TEntity>().SqlQuery(sql, new object[] { }).ToList();
                 return entity;
             }
         }
         public virtual async Task<List<TEntity>> GetEntityQuerySqlAsy(string sql)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 return await dbHelper.Set<TEntity>().SqlQuery(sql, new object[] { }).ToListAsync();
             }
         }

         public virtual List<TEntity> GetEntityLisrByWhere(Expression<Func<TEntity, bool>> fun)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 var entity = dbHelper.Set<TEntity>().AsNoTracking().Where(fun).ToList();
                 return entity;
             }
         }
         public virtual async Task<List<TEntity>> GetEntityLisrByWhereAsy(Expression<Func<TEntity, bool>> fun)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                return await dbHelper.Set<TEntity>().AsNoTracking().Where(fun).ToListAsync();
             }
         }

         public virtual int AddEntity(List<TEntity> list)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 dbHelper.Configuration.AutoDetectChangesEnabled = false;
                 try
                 {
                     dbHelper.Set<TEntity>().AddRange(list);
                     return dbHelper.SaveChanges();
                 }
                 finally
                 {
                     dbHelper.Configuration.AutoDetectChangesEnabled = true;
                 }
             }
         }
         public virtual async Task<int> AddEntityAys(List<TEntity> list)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 dbHelper.Configuration.AutoDetectChangesEnabled = false;
                 try
                 {
                     dbHelper.Set<TEntity>().AddRange(list);
                     return await dbHelper.SaveChangesAsync();
                 }
                 finally
                 {
                     dbHelper.Configuration.AutoDetectChangesEnabled = true;
                 }
             }
         }

         public virtual int DelEntity(TKey key)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 var entity = dbHelper.Set<TEntity>().Find(key);
                 dbHelper.Set<TEntity>().Remove(entity);
                 return dbHelper.SaveChanges();
             }
         }
         public virtual async Task<int> DelEntityAsy(TKey key)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 var entity = dbHelper.Set<TEntity>().Find(key);
                 dbHelper.Set<TEntity>().Remove(entity);
                 return await dbHelper.SaveChangesAsync(); ;
             }
         }

         public virtual int DelEntity(Dictionary<string, object> where)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 if (where == null || where.Keys.Count <= ) return ;
                 StringBuilder sb = new StringBuilder();
                 List<string> KeyList = new List<string>(where.Keys);
                 List<SqlParameter> plist = new List<SqlParameter>();
                 for (int i = , j = KeyList.Count; i < j; i++)
                 {
                     plist.Add(new SqlParameter()
                     {
                         ParameterName = KeyList[i],
                         Value = where[KeyList[i]]
                     });
                     if (i == j - )
                     {
                         sb.Append(string.Format(" {0}=@{0} ", KeyList[i]));
                     }
                     sb.Append(string.Format("{0}=@{0} and ", KeyList[i]));
                 }
                 string TableName = this.GetType().Name;
                 string sql = string.Format("delete from [{0}] where {1}", TableName, sb.ToString());
                 dbHelper.Set<TEntity>().SqlQuery(sql, plist);
                 return dbHelper.SaveChanges();
             }
         }
         public virtual async Task<int> DelEntityAsy(Dictionary<string, object> where)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 if (where == null || where.Keys.Count <= ) return ;
                 StringBuilder sb = new StringBuilder();
                 List<string> KeyList = new List<string>(where.Keys);
                 List<SqlParameter> plist = new List<SqlParameter>();
                 for (int i = , j = KeyList.Count; i < j; i++)
                 {
                     plist.Add(new SqlParameter()
                     {
                         ParameterName = KeyList[i],
                         Value = where[KeyList[i]]
                     });
                     if (i == j - )
                     {
                         sb.Append(string.Format(" {0}=@{0} ", KeyList[i]));
                     }
                     sb.Append(string.Format("{0}=@{0} and ", KeyList[i]));
                 }
                 string TableName = this.GetType().Name;
                 string sql = string.Format("delete from [{0}] where {1}", TableName, sb.ToString());
                 dbHelper.Set<TEntity>().SqlQuery(sql, plist);
                 return await dbHelper.SaveChangesAsync();
             }
         }

         public virtual TEntity GetEntityByWhere(Expression<Func<TEntity, bool>> fun)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 var entity = dbHelper.Set<TEntity>().AsNoTracking().Where(fun).FirstOrDefault();
                 return entity;
             }
         }
         public virtual async Task<TEntity> GetEntityByWhereAsy(Expression<Func<TEntity, bool>> fun)
         {
             using (DBContextHelper dbHelper = new DBContextHelper())
             {
                 return await dbHelper.Set<TEntity>().AsNoTracking().Where(fun).FirstOrDefaultAsync();
             }
         }

         public virtual int AddTable(string tableName, DataTable table)
         {
             if (string.IsNullOrEmpty(tableName) || table==null || table.Rows.Count<)
                 return -;
             else
             {
                 using (DBContextHelper dbHelper = new DBContextHelper())
                 {
                     try
                     {
                         if (dbHelper.Database.Connection.State != ConnectionState.Open)
                         {
                             var bulkCopy = new SqlBulkCopy((SqlConnection)dbHelper.Database.Connection);
                             bulkCopy.DestinationTableName = tableName;
                             bulkCopy.WriteToServer(table);
                         }
                         return table.Rows.Count;
                     }
                     catch (Exception e)
                     {
                         throw e;
                     }
                     finally {
                         if (dbHelper.Database.Connection.State != ConnectionState.Closed)
                         {
                             dbHelper.Database.Connection.Close();
                         }
                     }
                 }
             }
         }
         public virtual async Task<int> AddTableAsy(string tableName, DataTable table)
         {
             if (string.IsNullOrEmpty(tableName) || table == null || table.Rows.Count < )
                 return -;
             else
             {
                 using (DBContextHelper dbHelper = new DBContextHelper())
                 {
                     try
                     {
                         if (dbHelper.Database.Connection.State != ConnectionState.Open)
                         {
                             var bulkCopy = new SqlBulkCopy((SqlConnection)dbHelper.Database.Connection);
                             bulkCopy.DestinationTableName = tableName;
                             await bulkCopy.WriteToServerAsync(table);
                         }
                         return table.Rows.Count;
                     }
                     catch (Exception e)
                     {
                         throw e;
                     }
                     finally
                     {
                         if (dbHelper.Database.Connection.State != ConnectionState.Closed)
                         {
                             dbHelper.Database.Connection.Close();
                         }
                     }
                 }
             }
         }
     }