BIM工程信息管理系統-EF實體框架數據操做基類

時間 2019-11-07

標籤 bim 工程信息管理系統實體框架數據简体版

原文原文鏈接

EF實體框架數據操做基類主要是規範增、改、查、分頁、Lambda表達式條件處理，以及異步操做等特性，這樣可以儘量的符合基類這個特殊類的定義，實現功能接口的最大化重用和統一。html

一、程序代碼

 /// <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 - 1) * 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()

二、日誌記錄組件採用 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>

配置文件

轉自：https://www.cnblogs.com/w2011/p/11286124.htmlsql