EF实体框架数据操作基类主要是规范增、改、查、分页、Lambda表达式条件处理,以及异步操作等特性,这样能够尽可能的符合基类这个特殊类的定义,实现功能接口的最大化重用和统一。

1、程序代码

 /// <summary>
/// MSSQL数据库 数据层的父类
/// </summary>
/// <typeparam name="T"></typeparam>
public class BaseDAL<T> where T : class
{
//EF上下文
private readonly DbContext _db;
      #region 00 单例模式

        private static BaseDAL<T> _mInstance = null;
private static object obj = new object(); public BaseDAL(DbContext db)
{
_db = db;
} public static BaseDAL<T> ManagerContent(DbContext dbContext)
{
if (_mInstance == null)
{
lock (obj)
{
_mInstance = new BaseDAL<T>(dbContext);
}
}
return _mInstance;
} #endregion

00 单例模式

 #region 1.0 新增 实体 +int Add(T model)
/// <summary>
/// 新增 实体
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool Add(T model)
{
try
{
_db.Set<T>().Add(model);
_db.SaveChanges();
//保存成功后,会将自增的id设置给 model的 主键属性,并返回受影响行数
}
catch (EntityException ex)
{
LogHelper.Error("Add", ex);
LogHelper.Error(ex.Message); throw ex.InnerException;
}
catch (DbException exc)
{
LogHelper.Error("Add", exc);
throw exc.InnerException;
}
return true;
}
#endregion

1.0 新增 实体 +int Add(T model)

 #region 2.0 根据 id 删除 +bool Del(T model)
/// <summary>
/// 根据 id 删除
/// </summary>
/// <param name="model">包含要删除id的对象</param>
/// <returns></returns>
public bool Del(T model)
{
try
{
_db.Set<T>().Attach(model);
_db.Set<T>().Remove(model);
_db.SaveChanges();
}
catch (EntityException ex)
{
LogHelper.Error("Add", ex);
LogHelper.Error(ex.Message); throw ex.InnerException;
}
catch (DbException exc)
{
LogHelper.Error("Add", exc);
throw exc.InnerException;
}
return true;
}
#endregion

2.0 根据 id 删除 +bool Del(T model)

      #region 3.0 根据条件删除 +bool DelBy(Expression<Func<T, bool>> delWhere)
/// <summary>
/// 3.0 根据条件删除
/// </summary>
/// <param name="delWhere"></param>
/// <returns></returns>
public bool DelBy(Expression<Func<T, bool>> delWhere)
{
try
{
//3.1查询要删除的数据
List<T> listDeleting = _db.Set<T>().Where(delWhere).ToList();
//3.2将要删除的数据 用删除方法添加到 EF 容器中
listDeleting.ForEach(u =>
{
_db.Set<T>().Attach(u);//先附加到 EF容器
_db.Set<T>().Remove(u);//标识为 删除 状态
});
//3.3一次性 生成sql语句到数据库执行删除
_db.SaveChanges();
}
catch (EntityException ex)
{
LogHelper.Error("Add", ex);
LogHelper.Error(ex.Message); throw ex.InnerException;
}
catch (DbException exc)
{
LogHelper.Error("Add", exc);
throw exc.InnerException;
}
return true;
}
#endregion

3.0 根据条件删除 +bool DelBy(Expression<Func<T, bool>> delWhere)

  #region 4.0 修改 +bool Modify(T model, params string[] proNames)
/// <summary>
/// 4.0 修改,如:
/// T u = new T() { uId = 1, uLoginName = "asdfasdf" };
/// this.Modify(u, "uLoginName");
/// </summary>
/// <param name="model">要修改的实体对象</param>
/// <param name="proNames">要修改的 属性 名称</param>
/// <returns></returns>
public bool Modify(T model, params string[] proNames)
{
try
{
//4.1将 对象 添加到 EF中
DbEntityEntry entry = _db.Entry<T>(model);
//4.2先设置 对象的包装 状态为 Unchanged
entry.State = EntityState.Unchanged;
//4.3循环 被修改的属性名 数组
foreach (string proName in proNames)
{
//4.4将每个 被修改的属性的状态 设置为已修改状态;后面生成update语句时,就只为已修改的属性 更新
entry.Property(proName).IsModified = true;
}
//4.4一次性 生成sql语句到数据库执行
_db.SaveChanges();
}
catch (EntityException ex)
{
LogHelper.Error("Add", ex);
LogHelper.Error(ex.Message); throw ex.InnerException;
}
catch (DbException exc)
{
LogHelper.Error("Add", exc);
throw exc.InnerException;
} return true;
}
#endregion

4.0 修改 +bool Modify(T model, params string[] proNames)

  #region 4.1 批量修改 +bool Modify(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedProNames)
/// <summary>
/// 4.0 批量修改
/// </summary>
/// <param name="model">要修改的实体对象</param>
/// <param name="whereLambda">查询条件</param>
/// <param name="modifiedProNames">要修改的 属性 名称</param>
/// <returns></returns>
public bool ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedProNames)
{
try
{
//4.1查询要修改的数据
List<T> listModifing = _db.Set<T>().Where(whereLambda).ToList(); //获取 实体类 类型对象
Type t = typeof(T); // model.GetType();
//获取 实体类 所有的 公有属性
List<PropertyInfo> proInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
//创建 实体属性 字典集合
Dictionary<string, PropertyInfo> dictPros = new Dictionary<string, PropertyInfo>();
//将 实体属性 中要修改的属性名 添加到 字典集合中 键:属性名 值:属性对象
proInfos.ForEach(p =>
{
if (modifiedProNames.Contains(p.Name))
{
dictPros.Add(p.Name, p);
}
}); //4.3循环 要修改的属性名
foreach (string proName in modifiedProNames)
{
//判断 要修改的属性名是否在 实体类的属性集合中存在
if (dictPros.ContainsKey(proName))
{
//如果存在,则取出要修改的 属性对象
PropertyInfo proInfo = dictPros[proName];
//取出 要修改的值
object newValue = proInfo.GetValue(model, null); //object newValue = model.uName; //4.4批量设置 要修改 对象的 属性
foreach (T usrO in listModifing)
{
//为 要修改的对象 的 要修改的属性 设置新的值
proInfo.SetValue(usrO, newValue, null); //usrO.uName = newValue;
}
}
}
//4.4一次性 生成sql语句到数据库执行
_db.SaveChanges();
}
catch (EntityException ex)
{
LogHelper.Error("Add", ex);
LogHelper.Error(ex.Message); throw ex.InnerException;
}
catch (DbException exc)
{
LogHelper.Error("Add", exc);
throw exc.InnerException;
} return true;
}
#endregion

4.1 批量修改 +bool Modify(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedProNames)

   #region 4.2 修改个单个实体
public bool Modify(T model)
{
try
{
_db.Entry(typeof (T)).State = EntityState.Modified;
//4.4一次性 生成sql语句到数据库执行
_db.SaveChanges();
}
catch (EntityException ex)
{
LogHelper.Error("Add", ex);
LogHelper.Error(ex.Message); throw ex.InnerException;
}
catch (DbException exc)
{
LogHelper.Error("Add", exc);
throw exc.InnerException;
} return true;
}
#endregion

4.2 修改个单个实体

#region 5.0 根据条件查询 +IQueryable<T> GetListBy(Expression<Func<T,bool>> whereLambda)
/// <summary>
/// 5.0 根据条件查询 +List<T> GetListBy(Expression<Func<T,bool>> whereLambda)
/// </summary>
/// <param name="whereLambda">Lambda表达式</param>
/// <returns></returns>
public IQueryable<T> GetListBy(Expression<Func<T, bool>> whereLambda)
{
try
{
return _db.Set<T>().Where(whereLambda);
}
catch (EntityException ex)
{
LogHelper.Error("Add", ex);
LogHelper.Error(ex.Message); throw ex.InnerException;
}
catch (DbException exc)
{
LogHelper.Error("Add", exc);
throw exc.InnerException;
}
}
#endregion

5.0 根据条件查询 +IQueryable GetListBy(Expression<Func<T,bool>> whereLambda)

#region 5.1 根据条件 排序 和查询 + IQueryable<T> GetListBy<TKey>
/// <summary>
/// 5.1 根据条件 排序 和查询
/// </summary>
/// <typeparam name="TKey">排序字段类型</typeparam>
/// <param name="whereLambda">查询条件 lambda表达式</param>
/// <param name="orderLambda">排序条件 lambda表达式</param>
/// <returns></returns>
public IQueryable<T> GetListBy<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda)
{
try
{
return _db.Set<T>().Where(whereLambda).OrderBy(orderLambda);
}
catch (EntityException ex)
{
LogHelper.Error("Add", ex);
LogHelper.Error(ex.Message); throw ex.InnerException;
}
catch (DbException exc)
{
LogHelper.Error("Add", exc);
throw exc.InnerException;
}
}
#endregion

5.1 根据条件 排序 和查询 + IQueryable GetListBy

#region 5.2 根据条件查询 返回单条数据 T GetEntity(Expression<Func<T, bool>> whereLambda)

        public T GetEntity(Expression<Func<T, bool>> whereLambda)
{
try
{
return _db.Set<T>().First(whereLambda);
}
catch (EntityException ex)
{
LogHelper.Error("Add", ex);
LogHelper.Error(ex.Message); throw ex.InnerException;
}
catch (DbException exc)
{
LogHelper.Error("Add", exc);
throw exc.InnerException;
}
}
#endregion

5.2 根据条件查询 返回单条数据 T GetEntity(Expression<Func<T, bool>> whereLambda)

    #region 6.0 分页查询 + IQueryable<T> GetPagedList<TKey>
/// <summary>
/// 6.0 分页查询 + IQueryable<T> GetPagedList<TKey>
/// </summary>
/// <param name="pageIndex">页码</param>
/// <param name="pageSize">页容量</param>
/// <param name="whereLambda">条件 lambda表达式</param>
/// <param name="orderBy">排序 lambda表达式</param>
/// <returns></returns>
public IQueryable<T> GetPagedList<TKey>(int pageIndex, int pageSize, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderBy)
{
// 分页 一定注意: Skip 之前一定要 OrderBy
try
{
return _db.Set<T>().Where(whereLambda).OrderBy(orderBy).Skip((pageIndex - ) * pageSize).Take(pageSize);
}
catch (EntityException ex)
{
LogHelper.Error("Add", ex);
LogHelper.Error(ex.Message); throw ex.InnerException;
}
catch (DbException exc)
{
LogHelper.Error("Add", exc);
throw exc.InnerException;
}
}
#endregion

6.0 分页查询 + IQueryable GetPagedList

#region 7.0执行SQL+string ExecMaxValueSql()
public string ExecMaxValueSql()
{
string sql = @"begin tran
DECLARE @Value bigint
update " + typeof(T).Name + @"
set value = value+1;
select @Value = value from " + typeof(T).Name + @";
select cast(@Value as varchar(10));
commit tran";
string value = _db.Database.SqlQuery<string>(sql).First(); return value;
}
#endregion

7.0执行SQL+string ExecMaxValueSql()

   }

2、 日志记录组件采用 Log4Net

   public class LogHelper
{
private static readonly log4net.ILog Log = log4net.LogManager.GetLogger("ApplicationLog");
public static void Info(string info)
{
Log.Info(info);
}
public static void Info(string info, Exception ex)
{
Log.Info(info, ex);
}
public static void Error(string info, Exception ex)
{
Log.Info(info, ex);
}
public static void Error(string info)
{
Log.Error(info);
}
public void Debug(string info)
{
Log.Debug(info);
}
public void Debug(string info, Exception se)
{
Log.Debug(info, se);
}
public void Warn(string info)
{
Log.Warn(info);
}
public void Warn(string info, Exception ex)
{
Log.Warn(info, ex);
}
public void Fatal(string info)
{
Log.Fatal(info);
}
public void Fatal(string info, Exception ex)
{
Log.Fatal(info, ex);
}
}

日志记录

<?xml version="1.0" encoding="utf-8" ?>
<log4net>
<logger name="ApplicationLog">
<level value="INFO" />
<appender-ref ref="rollingFile" />
</logger> <appender name="rollingFile" type="log4net.Appender.RollingFileAppender, log4net" >
<param name="File" value="ServiceLog.txt" />
<param name="AppendToFile" value="true" />
<param name="RollingStyle" value="Date" />
<param name="MaximumFileSize" value="5MB"></param>
<param name="DatePattern" value="_yyyy.MM.dd" />
<param name="StaticLogFileName" value="true" />
<layout type="log4net.Layout.PatternLayout, log4net">
<param name="ConversionPattern" value="%d - %m%n" />
</layout>
</appender>
</log4net>

配置文件

BIM工程信息管理系统-EF实体框架数据操作基类的更多相关文章

  1. EF实体框架数据操作基类(转)

    //----------------------------------------------------------------// Copyright (C) 2013 河南禄恒软件科技有限公司 ...

  2. EF实体框架数据操作接口(转)

    //----------------------------------------------------------------// Copyright (C) 2013 河南禄恒软件科技有限公司 ...

  3. BIM工程信息管理系统-详细设计

    详细设计说明书 1引言 1.1编写目的 编写详细设计说明书的目的就是为程序员写出实际的程序代码提供依据.它是软件详细设计阶段所有任务和所有相关人员所需的参考资料. 1.2背景 说明: a.  软件名称 ...

  4. BIM工程信息管理系统搭建-系统功能需求

    BIM工程信息管理系统功能需求 该系统是真实存在项目,项目于2013年开始研发到2014年初完成,按照当时技术能力和国内BIM现状,现在BIM技术已比之前好多了,不管是建模.展示等.均提高了不少,本博 ...

  5. EF实体框架之CodeFirst一

    对于SQL Server.MySql.Oracle等这些传统的数据库,基本都是关系型数据库,都是体现实体与实体之间的联系,在以前开发时,可能先根据需求设计数据库,然后在写Model和业务逻辑,对于Mo ...

  6. EF实体框架之CodeFirst四

    在EF实体框架之CodeFirst二中也提到数据库里面一般包括表.列.约束.主外键.级联操作.实体关系(E-R图).存储过程.视图.锁.事务.数据库结构更新等.前面几篇博客把表.存储过程.视图这些算是 ...

  7. C#.Net EF实体框架入门视频教程

    当前位置: 主页 > 编程开发 > C_VC视频教程 > C#.Net EF实体框架入门视频教程 > kingstone金士顿手机内存卡16G仅65元 1.EF实体框架之增加查 ...

  8. EF实体框架处理实体之间关联关系与EF延迟机制(下)

    在数据库中,表与表之间可能存在多种联系,比如,一对多,多对多的关系.当我们使用逻辑外键在数据库建立两张表之间的关系的时候,我们使用EF实体框架 必然也会将这种关系映射到我们的实体关系中来.所以,在我们 ...

  9. 【MVC 1】MVC+EF实体框架—原理解析

    导读:在之前,我们学过了三层框架,即:UI.BLL.DAL.我们将页面显示.逻辑处理和数据访问进行分层,避免了一层.两层的混乱.而后,我们又在经典三层的基础上,应用设计模式:外观.抽象工厂+反射,使得 ...

随机推荐

  1. 使用echarts去对数据进行图形分析

    首先导入js包:echarts.min.js <script type="text/javascript" src="js/echarts.min.js" ...

  2. ARTS-S pytorch中Conv2d函数padding和stride含义

    padding是输入数据最边缘补0的个数,默认是0,即不补0. stride是进行一次卷积后,特征图滑动几格,默认是1,即滑动一格.

  3. Selenium之xpath绝对路径表示法

    xpath写法: 绝对路径:以/开始,逐个增加节点用/分割 特点:不能跨级.类似css中的直接子元素选择器 相对路径:用两个斜杠  //      如  //div//p//a 通配符:xpath也有 ...

  4. 【MySql】使用学习

    [MySql]使用学习 =================================================== 1.太多的连接 Too many connections ======= ...

  5. 【Java Web开发学习】Spring MVC异常统一处理

    [Java Web开发学习]Spring MVC异常统一处理 文采有限,若有错误,欢迎留言指正. 转载:https://www.cnblogs.com/yangchongxing/p/9271900. ...

  6. 手动启动Oracle服务的.bat文件

    Oracle数据库的基本服务会占用很大的内存,有的程序员会在不用的时候Oracle服务关闭来减少对电脑内存资源的占用. 我在这准备了一个可以开启/关闭Oracle服务的bat文件,希望被采纳!!! 新 ...

  7. mysql数据库密码的修改与恢复

    一.mysql密码的修改与恢复 1.修改密码 mysqladmin -u root -p123 password 456 数据库内修改 method.first: update mysql.user ...

  8. poj 1679 The Unique MST (次小生成树模板题)

    Given a connected undirected graph, tell if its minimum spanning tree is unique. Definition 1 (Spann ...

  9. java8-Stream流API

    一回顾与说明 经过前面发布的三章java8的博客,你就懂得了我们为什么要用Lamda表达式,Lamda表达式的原理与函数式接口的关系,从Lamda表达式到方法引用和构造引用. 想要学Stream流你必 ...

  10. 面试连环炮系列(二十一):你们的项目怎么使用kafka

    你们的项目怎么使用kafka? 我们采用kafka进行日志采集,准确点说是ELK方案,即elasticsearch + logstash + kibana + kafka.通过Spring AOP的方 ...