entity framework 6 自己编写的通用数据类

最新推荐文章于 2024-08-12 08:32:44 发布

小蚂蚁_CrkRes

最新推荐文章于 2024-08-12 08:32:44 发布

阅读量529

点赞数 1

分类专栏： C#

C# 专栏收录该内容

41 篇文章

订阅专栏

本文介绍了一个基于ORM框架的通用数据访问层实现方法，包括实体的增删改查、条件查询、排序、分页等功能，并提供了具体的代码实现示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

 public class BaseDAL  
   {  
       string strConn = "";  
       public BaseDAL(string connString)  
       {  
           strConn = connString;  
       }  
 
       #region 通用增删改查  
       #region 非原始sql语句方式  
       /// <summary>  
       /// 新增  
       /// </summary>  
       /// <param name="entity">实体</param>  
       /// <returns>返回受影响行数</returns>  
       public bool Add<T>(T entity) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               db.Entry<T>(entity).State = EntityState.Added;  
               return db.SaveChanges() > 0;  
           }  
       }  
  
       /// <summary>  
       /// 修改  
       /// </summary>  
       /// <param name="entity">实体</param>  
       /// <returns>返回受影响行数</returns>  
       public bool Update<T>(T entity) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               db.Set<T>().Attach(entity);  
               db.Entry<T>(entity).State = EntityState.Modified;  
               return db.SaveChanges() > 0;  
           }  
       }  
  
       /// <summary>  
       /// 删除  
       /// </summary>  
       /// <param name="entity">实体</param>  
       /// <returns>返回受影响行数</returns>  
       public bool Delete<T>(T entity) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               db.Set<T>().Attach(entity);  
               db.Entry<T>(entity).State = EntityState.Deleted;  
               return db.SaveChanges() > 0;  
           }  
       }  
  
       /// <summary>  
       /// 根据条件删除  
       /// </summary>  
       /// <param name="deleWhere">删除条件</param>  
       /// <returns>返回受影响行数</returns>  
       public bool DeleteByConditon<T>(Expression<Func<T, bool>> deleWhere) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               List<T> entitys = db.Set<T>().Where(deleWhere).ToList();  
               entitys.ForEach(m => db.Entry<T>(m).State = EntityState.Deleted);  
               return db.SaveChanges() > 0;  
           }  
       }  
  
       /// <summary>  
       /// 查找单个  
       /// </summary>  
       /// <param name="id">主键</param>  
       /// <returns></returns>  
       public T GetSingleById<T>(int id) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               return db.Set<T>().Find(id);  
           }  
       }  
  
       /// <summary>  
       /// 查找单个  
       /// </summary>  
       /// <param name="seleWhere">查询条件</param>  
       /// <returns></returns>  
       public T GetSingle<T>(Expression<Func<T, bool>> seleWhere) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               return db.Set<T>().AsExpandable().FirstOrDefault(seleWhere);  
           }  
       }  
  
       /// <summary>  
       /// 获取所有实体集合  
       /// </summary>  
       /// <returns></returns>  
       public List<T> GetAll<T>() where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               return db.Set<T>().AsExpandable().ToList<T>();  
           }  
       }  
  
       /// <summary>  
       /// 获取所有实体集合(单个排序)  
       /// </summary>  
       /// <returns></returns>  
       public List<T> GetAll<T, Tkey>(Expression<Func<T, Tkey>> orderWhere, bool isDesc) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               return CommonSort(db.Set<T>().AsExpandable(), orderWhere, isDesc).ToList<T>();  
           }  
       }  
  
       /// <summary>  
       /// 获取所有实体集合(多个排序)  
       /// </summary>  
       /// <returns></returns>  
       public List<T> GetAll<T>(params OrderModelField[] orderByExpression) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               return CommonSort(db.Set<T>().AsExpandable(), orderByExpression).ToList();  
           }  
       }  
  
       /// <summary>  
       /// 单个排序通用方法  
       /// </summary>  
       /// <typeparam name="Tkey">排序字段</typeparam>  
       /// <param name="data">要排序的数据</param>  
       /// <param name="orderWhere">排序条件</param>  
       /// <param name="isDesc">是否倒序</param>  
       /// <returns>排序后的集合</returns>  
       public IQueryable<T> CommonSort<T, Tkey>(IQueryable<T> data, Expression<Func<T, Tkey>> orderWhere, bool isDesc) where T : class  
       {  
           if (isDesc)  
           {  
               return data.OrderByDescending(orderWhere);  
           }  
           else  
           {  
               return data.OrderBy(orderWhere);  
           }  
       }  
  
       /// <summary>  
       /// 多个排序通用方法  
       /// </summary>  
       /// <typeparam name="Tkey">排序字段</typeparam>  
       /// <param name="data">要排序的数据</param>  
       /// <param name="orderWhereAndIsDesc">字典集合(排序条件,是否倒序)</param>  
       /// <returns>排序后的集合</returns>  
       public IQueryable<T> CommonSort<T>(IQueryable<T> data, params OrderModelField[] orderByExpression) where T : class  
       {  
           //创建表达式变量参数  
           var parameter = Expression.Parameter(typeof(T), "o");  
  
           if (orderByExpression != null && orderByExpression.Length > 0)  
           {  
               for (int i = 0; i < orderByExpression.Length; i++)  
               {  
                   //根据属性名获取属性  
                   var property = typeof(T).GetProperty(orderByExpression[i].PropertyName);  
                   //创建一个访问属性的表达式  
                   var propertyAccess = Expression.MakeMemberAccess(parameter, property);  
                   var orderByExp = Expression.Lambda(propertyAccess, parameter);  
  
                   string OrderName = "";  
                   if (i > 0)  
                   {  
                       OrderName = orderByExpression[i].IsDESC ? "ThenByDescending" : "ThenBy";  
                   }  
                   else  
                       OrderName = orderByExpression[i].IsDESC ? "OrderByDescending" : "OrderBy";  
  
                   MethodCallExpression resultExp = Expression.Call(typeof(Queryable), OrderName, new Type[] { typeof(T), property.PropertyType },  
                       data.Expression, Expression.Quote(orderByExp));  
  
                   data = data.Provider.CreateQuery<T>(resultExp);  
               }  
           }  
           return data;  
       }  
  
       /// <summary>  
       /// 根据条件查询实体集合  
       /// </summary>  
       /// <param name="seleWhere">查询条件 lambel表达式</param>  
       /// <returns></returns>  
       public List<T> GetList<T>(Expression<Func<T, bool>> seleWhere) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               return db.Set<T>().AsExpandable().Where(seleWhere).ToList();  
           }  
       }  
  
       /// <summary>  
       /// 根据条件查询实体集合  
       /// </summary>  
       /// <param name="seleWhere">查询条件 lambel表达式</param>  
       /// <returns></returns>  
       public List<T> GetList<T, TValue>(Expression<Func<T, TValue>> seleWhere, IEnumerable<TValue> conditions) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
  
               return db.Set<T>().AsExpandable().WhereIn<T, TValue>(seleWhere, conditions).ToList();  
           }  
       }  
  
       /// <summary>  
       /// 根据条件查询实体集合(单个字段排序)  
       /// </summary>  
       /// <param name="seleWhere">查询条件 lambel表达式</param>  
       /// <returns></returns>  
       public List<T> GetList<T, Tkey>(Expression<Func<T, bool>> seleWhere, Expression<Func<T, Tkey>> orderWhere, bool isDesc) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               return CommonSort(db.Set<T>().AsExpandable().Where(seleWhere), orderWhere, isDesc).ToList();  
           }  
       }  
  
       /// <summary>  
       /// 根据条件查询实体集合(多个字段排序)  
       /// </summary>  
       /// <param name="seleWhere">查询条件 lambel表达式</param>  
       /// <returns></returns>  
       public List<T> GetList<T>(Expression<Func<T, bool>> seleWhere, params OrderModelField[] orderByExpression) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               return CommonSort(db.Set<T>().AsExpandable().Where(seleWhere), orderByExpression).ToList();  
           }  
       }  
  
       /// <summary>  
       /// 获取分页集合(无条件无排序)  
       /// </summary>  
       /// <returns></returns>  
       public List<T> GetListPaged<T, Tkey>(int pageIndex, int pageSize, out int totalcount) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               totalcount = db.Set<T>().AsExpandable().Count();//获取总数  
               //需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法  
               return db.Set<T>().AsExpandable().Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();  
           }  
       }  
  
       /// <summary>  
       /// 获取分页集合(无条件单个排序)  
       /// </summary>  
       /// <returns></returns>  
       public List<T> GetListPaged<T, Tkey>(int pageIndex, int pageSize, Expression<Func<T, Tkey>> orderWhere, bool isDesc, out int totalcount) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               totalcount = db.Set<T>().AsExpandable().Count();//获取总数  
               //需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法  
               return CommonSort(db.Set<T>().AsExpandable(), orderWhere, isDesc).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();  
           }  
       }  
  
       /// <summary>  
       /// 获取分页集合(无条件多字段排序)  
       /// </summary>  
       /// <returns></returns>  
       public List<T> GetListPaged<T>(int pageIndex, int pageSize, out int totalcount, params OrderModelField[] orderByExpression) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               totalcount = db.Set<T>().AsExpandable().Count();//获取总数  
               //需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法  
               return CommonSort(db.Set<T>().AsExpandable(), orderByExpression).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();  
           }  
       }  
  
       /// <summary>  
       /// 获取分页集合(有条件无排序)  
       /// </summary>  
       /// <returns></returns>  
       public List<T> GetListPaged<T, Tkey>(int pageIndex, int pageSize, Expression<Func<T, bool>> seleWhere, out int totalcount) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               totalcount = db.Set<T>().AsExpandable().Where(seleWhere).Count();//获取总数  
               //需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法  
               return db.Set<T>().AsExpandable().Where(seleWhere).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();  
           }  
       }  
  
       /// <summary>  
       /// 获取分页集合(有条件单个排序)  
       /// </summary>  
       /// <returns></returns>  
       public List<T> GetListPaged<T, Tkey>(int pageIndex, int pageSize, Expression<Func<T, bool>> seleWhere,  
           Expression<Func<T, Tkey>> orderWhere, bool isDesc, out int totalcount) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               totalcount = db.Set<T>().AsExpandable().Where(seleWhere).Count();//获取总数  
               //需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法  
               return CommonSort(db.Set<T>().AsExpandable().Where(seleWhere), orderWhere, isDesc).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();  
           }  
       }  
  
       /// <summary>  
       /// 获取分页集合(有条件多字段排序)  
       /// </summary>  
       /// <returns></returns>  
       public List<T> GetListPaged<T>(int pageIndex, int pageSize, Expression<Func<T, bool>> seleWhere,  
           out int totalcount, params OrderModelField[] orderModelFiled) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               totalcount = db.Set<T>().AsExpandable().Where(seleWhere).Count();//获取总数  
               //需要增加AsExpandable(),否则查询的是所有数据到内存，然后再排序  AsExpandable是linqkit.dll中的方法  
               return CommonSort(db.Set<T>().AsExpandable().Where(seleWhere), orderModelFiled).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();  
           }  
       }  
       #endregion  
 
       #region 原始sql操作  
       /// <summary>  
       /// 执行操作  
       /// </summary>  
       /// <param name="sql"></param>  
       /// <param name="paras"></param>  
       public void ExecuteSql(string sql, params object[] paras)  
       {  
           using (SysDb db = new SysDb(strConn))  
           {  
               db.Database.ExecuteSqlCommand(sql, paras);  
           }  
       }  
  
       /// <summary>  
       /// 查询列表  
       /// </summary>  
       /// <typeparam name="T"></typeparam>  
       /// <param name="sql"></param>  
       /// <param name="paras"></param>  
       /// <returns></returns>  
       public List<T> QueryList<T>(string sql, params object[] paras) where T : class  
       {  
           using (SysDb db = new SysDb(strConn))  
           {  
               return db.Database.SqlQuery<T>(sql, paras).ToList();  
           }  
       }  
  
       /// <summary>  
       /// 查询单个  
       /// </summary>  
       /// <typeparam name="T"></typeparam>  
       /// <param name="sql"></param>  
       /// <param name="paras"></param>  
       /// <returns></returns>  
       public T QuerySingle<T>(string sql, params object[] paras) where T : class  
       {  
           using (SysDb<T> db = new SysDb<T>(strConn))  
           {  
               return db.Database.SqlQuery<T>(sql, paras).FirstOrDefault();  
           }  
       }  
  
       /// <summary>  
       /// 执行事务  
       /// </summary>  
       /// <param name="lsSql"></param>  
       /// <param name="lsParas"></param>  
       public void ExecuteTransaction(List<String> lsSql, List<Object[]> lsParas)  
       {  
           using (SysDb db = new SysDb(strConn))  
           {  
               using (var tran = db.Database.BeginTransaction())  
               {  
                   try  
                   {  
                       for (int i = 0; i < lsSql.Count; i++)  
                       {  
                           if (lsParas != null && lsParas.Count > 0)  
                           {  
                               db.Database.ExecuteSqlCommand(lsSql[i], lsParas[i]);  
                           }  
                       }  
                       foreach (String item in lsSql)  
                       {  
                           db.Database.ExecuteSqlCommand(item);  
                       }  
  
                       tran.Commit();  
                   }  
                   catch (Exception ex)  
                   {  
                       tran.Rollback();  
                       throw ex;  
                   }  
               }  
           }  
       }  
       #endregion  
       #endregion  
 
       #region 通用属性  
       /// <summary>  
       /// 获取数据库服务器当前时间。  
       /// </summary>  
       public DateTime ServerTime  
       {  
           get  
           {  
               using (SysDb db = new SysDb(strConn))  
               {  
                   String sql = "SELECT GETDATE()";  
                   Object objServerTime = db.Database.SqlQuery<Object>(sql);  
                   return Convert.ToDateTime(objServerTime);  
               }  
           }  
       }  
  
       /// <summary>  
       /// 获取数据库版本。  
       /// </summary>  
       public String DatabaseVersion  
       {  
           get  
           {  
               using (SysDb db = new SysDb(strConn))  
               {  
                   try  
                   {  
                       String sql = "SELECT Version FROM Sys_Version";  
                       Object objServerTime = db.Database.SqlQuery<Object>(sql);  
                       return Convert.ToString(objServerTime);  
                   }  
                   catch  
                   {  
                   }  
                   return String.Empty;  
               }  
           }  
       }  
       #endregion  
  
   }  
   public static class QueryableExtension  
   {  
       /// <summary>  
       /// 扩展方法  支持 in 操作  
       /// </summary>  
       /// <typeparam name="TEntity">需要扩展的对象类型</typeparam>  
       /// <typeparam name="TValue">in 的值类型</typeparam>  
       /// <param name="source">需要扩展的对象</param>  
       /// <param name="valueSelector">值选择器 例如c=>c.UserId</param>  
       /// <param name="values">值集合</param>  
       /// <returns></returns>  
       public static IQueryable<TEntity> WhereIn<TEntity, TValue>(this IQueryable<TEntity> source, Expression<Func<TEntity, TValue>> valueSelector,  
               IEnumerable<TValue> values)  
       {  
           if (null == valueSelector) { throw new ArgumentNullException("valueSelector"); }  
           if (null == values) { throw new ArgumentNullException("values"); }  
           ParameterExpression p = valueSelector.Parameters.Single();  
  
           if (!values.Any())  
           {  
               return source;  
           }  
           var equals = values.Select(value => (Expression)Expression.Equal(valueSelector.Body, Expression.Constant(value, typeof(TValue))));  
           var body = equals.Aggregate<Expression>((accumulate, equal) => Expression.Or(accumulate, equal));  
           return source.Where(Expression.Lambda<Func<TEntity, bool>>(body, p));  
       }  
   }  
   public struct OrderModelField  
   {  
  
       public bool IsDESC { get; set; }  
       public string PropertyName { get; set; }  
   }  

dbcontext类：

   [csharp] 
   view plaincopy
public class SysDb : DbContext  
{  
    bool isNew = true;//是否是新的sql执行  
    string strMsg = "";//sql执行的相关信息  
    string strConn = "";//数据库连接字符串  
    string UserName = "";//日志用户名称  
    string AdditionalInfo = "";//日志额外信息  
    public SysDb(string connString) : // 数据库链接字符串  
        base(connString)  
    {  
        strConn = connString;  
        Database.SetInitializer<SysDb>(null);//设置为空，防止自动检查和生成  
        base.Database.Log = (info) => Debug.WriteLine(info);  
    }  
  
    public SysDb(string connString, string logUserName, string logAdditionalInfo) : // 数据库链接字符串  
        base(connString)  
    {  
        strConn = connString;  
        Database.SetInitializer<SysDb>(null);//设置为空，防止自动检查和生成  
        UserName = logUserName;  
        AdditionalInfo = logAdditionalInfo;  
        base.Database.Log = AddLogger;  
    }  
  
    protected override void OnModelCreating(DbModelBuilder modelBuilder)  
    {  
        //去掉复数映射  
        modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();  
        base.OnModelCreating(modelBuilder);  
    }  
  
    /// <summary>  
    /// 添加日志  
    /// </summary>  
    /// <param name="info"></param>  
    public void AddLogger(string info)  
    {  
        if (info != "\r\n" && (!info.Contains("Sys_EventLog")))  
        {  
            string strTemp = info.ToUpper().Trim();  
            if (isNew)  
            {  
                //记录增删改  
                if (strTemp.StartsWith("INSERT") || strTemp.StartsWith("UPDATE") || strTemp.StartsWith("DELETE"))  
                {  
                    strMsg = info;  
                    isNew = false;  
                }  
            }  
            else  
            {  
                if (strTemp.StartsWith("CLOSED CONNECTION"))  
                {  
                    //增加新日志  
                    using (SysDb db = new SysDb(strConn))  
                    {  
                        try  
                        {  
//保存日志到数据库或其他地方  
  
                        }  
                        catch (Exception ex)  
                        {  
                            using (System.IO.StreamWriter sw = new System.IO.StreamWriter(AppDomain.CurrentDomain.BaseDirectory + "//logError.txt"))  
                            {  
                                sw.Write(ex.Message);  
                                sw.Flush();  
                            }  
                        }  
                    }  
                    //清空  
                    strMsg = "";  
                    isNew = true;  
                }  
                else  
                {  
                    strMsg += info;  
                }  
            }  
  
        }  
    }  
  
      
}  
public class SysDb<T> : SysDb where T : class  
{  
    public SysDb(string connString) : // 数据库链接字符串  
        base(connString)  
    {  
        Database.SetInitializer<SysDb<T>>(null);//设置为空，防止自动检查和生成  
    }  
  
    public SysDb(string connString, string logUserName, string logAdditionalInfo) : // 数据库链接字符串  
        base(connString,logUserName,logAdditionalInfo)  
    {  
        Database.SetInitializer<SysDb<T>>(null);//设置为空，防止自动检查和生成  
    }  
  
    public DbSet<T> Entities { get; set; }  
}  

界面使用：（bll层忽略）

   [csharp] 
   view plaincopy
public class BusinessController : Controller  
   {  
       //  
       // GET: /Jygl/Business/  
       BaseBLL basebll = new BaseBLL(WebHelper.Conn);  
  
       public ActionResult GetXMList(int page,int rows)  
       {  
           int count = 0;  
           //查询条件  
           //Expression<Func<JY_XM, bool>> searchPredicate = PredicateBuilder.True<JY_XM>();  
           //searchPredicate = searchPredicate.And(c => c.UserName.Contains(""));  
           Expression<Func<JY_XM, int>> keySelector = u => u.UID;  
           string str = ExceptionHelper<JY_XM>.TryCatchPageQueryJson<int>(basebll.GetListPaged, page, rows, keySelector, false, out count);  
           return Content(str);   
       }  
  
       [HttpPost]  
       public ActionResult XMEdit(JY_XM jyxm)  
       {  
           basebll.Add(jyxm);  
           return View();  
       }  
  
       public ActionResult GetAllGCLB()  
       {  
  
           List<DICT_GCLB> lsGCLB = basebll.GetAll<DICT_GCLB>();  
           DICT_GCLB dicNew=new DICT_GCLB();  
           dicNew.GCLBText="-请选择-";  
           dicNew.GCLBId=0;  
           lsGCLB.Add(dicNew);  
  
           return Content(WebHelper.Json(lsGCLB));  
       }  
  
       public ActionResult GetAllArea()  
       {  
           List<DICT_Area> lsArea = basebll.GetAll<DICT_Area>();  
           DICT_Area dicNew=new DICT_Area();  
           dicNew.AreaText="-请选择-";  
           dicNew.AreaId=0;  
           lsArea.Add(dicNew);  
           return Content(WebHelper.Json(lsArea));  
       }  
   }  