让EF支持sql语句

BaseDal类：

    public class BaseDal : IDisposable
    {
        #region 事件
        internal Func<bool> DBCommitting;
        internal Action<bool> DBCommitted;

        internal Func<object, bool> DBAdding;
        internal Action<object, bool> DBAdded;
        internal Func<object, bool> DBUpdating;
        internal Action<object, bool> DBUpdated;
        internal Func<object, bool> DBDeleting;
        internal Action<object, bool> DBDeleted;

        internal Func<object, bool, bool> DBSaveOrUpdating;
        internal Action<object, bool, bool> DBSaveOrUpdated;
        internal Func<object, bool, bool> DBSaveOrUpdatingForList;
        internal Action<object, bool, bool> DBSaveOrUpdatedForList;
        #endregion

        private DBEntities db = new DBEntities();//实体模型名

        private bool isTransaction = false;

        public bool IsBeginTranscation { get { return isTransaction; } }

        public IQueryable<T> GetEntity<T>() where T : class
        {
            return db.Set<T>().AsNoTracking().AsQueryable<T>();
        }

        /// <summary>
        /// 添加
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="lst"></param>
        /// <returns></returns>
        public bool Add<T>(List<T> lst, bool isCommit = true) where T : class
        {
            foreach (var item in lst)
            {
                db.Entry<T>(item).State = System.Data.EntityState.Added;
            }

            if (isCommit && !isTransaction)
            {
                bool isContinue = true;
                if (DBAdding != null) isContinue = DBAdding(lst);
                if (isContinue)
                {
                    var ret = db.SaveChanges() > 0;
                    if (DBAdded != null) DBAdded(lst, ret);

                    return ret;
                }
                else
                    return false;
            }
            else
                return false;

        }

        /// <summary>
        /// 根据条件删除
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public bool DeleteByCondition<T>(Expression<Func<T, bool>> predicate, bool isCommit = true) where T : class
        {
            db.Set<T>().Where<T>(predicate).ToList<T>().ForEach(d =>
            {
                db.Entry<T>(d).State = System.Data.EntityState.Deleted;
            });
            if (isCommit && !isTransaction)
            {
                bool isContinue = true;
                if (DBDeleting != null) isContinue = DBDeleting(predicate);
                if (isContinue)
                {
                    var ret = db.SaveChanges() > 0;
                    if (DBDeleted != null) DBDeleted(predicate, ret);
                    return ret;
                }
                else
                    return false;
            }
            else
                return false;
        }

        public bool UpdateByCondition<T>(Action<T> updateExpression, Expression<Func<T, bool>> predicate, bool isCommit = true) where T : class
        {
            var lstDB = db.Set<T>().Where<T>(predicate).ToList<T>();
            var lstEF = db.Set<T>().Local.AsQueryable().Where(predicate).ToList<T>();
            lstDB.AddRange(lstEF);
            lstDB.ForEach(item =>
            {
                updateExpression(item);
                if (db.Entry<T>(item).State != EntityState.Deleted && db.Entry<T>(item).State != EntityState.Added)
                    db.Entry<T>(item).State = EntityState.Modified;
            });

            if (isCommit && !isTransaction)
            {
                bool isContinue = true;
                if (DBUpdating != null) isContinue = DBUpdating(predicate);
                if (isContinue)
                {
                    var ret = db.SaveChanges() > 0;
                    if (DBUpdated != null) DBUpdated(predicate, ret);

                    return ret;
                }
                else
                    return false;
            }
            else
            {
                return false;
            }
        }

        public bool SaveOrUpdate<T>(T entity, bool isAdd = false, bool isCommit = true) where T : class
        {
            if (isAdd)
                db.Set<T>().Add(entity);
            else
                db.Entry(entity).State = System.Data.EntityState.Modified;

            if (isCommit && !isTransaction)
            {
                bool isContinue = true;
                if (DBSaveOrUpdating != null) isContinue = DBSaveOrUpdating(entity, isAdd);
                if (isContinue)
                {
                    var ret = db.SaveChanges() > 0;
                    if (DBSaveOrUpdated != null) DBSaveOrUpdated(entity, isAdd, ret);
                    return ret;
                }
                else
                    return false;
            }
            else
                return false;

        }

        public bool SaveOrUpdateForList<T>(List<T> entities, bool isAdd = false, bool isCommit = true) where T : class
        {
            foreach (T entity in entities)
            {
                if (isAdd)
                    db.Set<T>().Add(entity);
                else
                    db.Entry(entity).State = System.Data.EntityState.Modified;
            }
            if (isCommit && !isTransaction)
            {
                bool isContinue = true;
                if (DBSaveOrUpdatingForList != null) isContinue = DBSaveOrUpdatingForList(entities, isAdd);
                if (isContinue)
                {
                    var ret = db.SaveChanges() > 0;
                    if (DBSaveOrUpdatedForList != null) DBSaveOrUpdatedForList(entities, isAdd, ret);

                    return ret;
                }
                else
                    return false;
            }
            else
                return false;
        }

        public int ExecuteSqlCommand(string sql, bool isCommit = true)
        {
            db.Database.ExecuteSqlCommand(sql);
            if (isCommit && !isTransaction)
                return db.SaveChanges();
            else
                return 0;
        }

        public int ExecuteSqlCommand(string sql, bool isCommit, params object[] parameters)
        {
            db.Database.ExecuteSqlCommand(sql, parameters);
            if (isCommit && !isTransaction)
                return db.SaveChanges();
            return 0;
        }
        
        /// <summary>
        ///  执行存储过程 无超时
        /// </summary>
        /// <param name="ProcName"></param>
        /// <param name="parList"></param>
        public void ExecPro(string ProcName, List<SqlParameter> parList)
        {
            DbConnection conn = db.Database.Connection;
            if (conn.State == ConnectionState.Closed)
                conn.Open();
            DbCommand cmd = conn.CreateCommand();
            cmd.CommandType = System.Data.CommandType.StoredProcedure;
            cmd.CommandText = ProcName;
            cmd.CommandTimeout = 0;
            foreach (SqlParameter par in parList)
            {
                cmd.Parameters.Add(par);
            }

            cmd.ExecuteNonQuery();
        }

        public void BeginTranscation()
        {
            isTransaction = true;
        }

        public bool Commit()
        {
            if (isTransaction)
            {
                bool isContinue = true;
                isTransaction = false;
                if (DBCommitting != null) isContinue = DBCommitting();
                if (isContinue)
                {
                    var ret = db.SaveChanges() > 0;
                    if (DBCommitted != null) DBCommitted(ret);
                    return ret;
                }
                else
                    return false;
            }
            else
                return false;
        }

        /// <summary>
        /// 执行SQL查询语句
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public List<T> FindEntityListBySql<T>(string sql)
        {
            return db.Database.SqlQuery<T>(sql).ToList<T>();
        }

        public void Close()
        {
            if (db != null)
            {
                db.Dispose();
                db = null;
            }
        }

        public void Dispose()
        {
            if (db != null)
            {
                db.Dispose();
                db = null;
            }
        }
    }

DBEvent类

    public class DBEvent<T> where T : class
    {
        protected BaseDal db;

        public DBEvent(BaseDal db)
        {
            this.db = db;
            db.DBUpdating = Updating;
            db.DBUpdated = Updated;
            db.DBAdding = Adding;
            db.DBAdded = Added;
            db.DBDeleting = Deleting;
            db.DBDeleted = Deleted;
            db.DBSaveOrUpdating = SaveOrUpdating;
            db.DBSaveOrUpdated = SaveOrUpdated;
            db.DBSaveOrUpdatingForList = SaveOrUpdatingForList;
            db.DBSaveOrUpdatedForList = SaveOrUpdatedForList;
            db.DBCommitting = Commintting;
            db.DBCommitted = Committed;
        }

        public delegate bool BeforeUpdateEvent(Expression<Func<T, bool>> predicate);

        public delegate void AfterUpdateEvent(Expression<Func<T, bool>> predicate, bool isSuccess);

        public delegate bool BeforeAddEvent(List<T> lstEntity);

        public delegate void AfterAddEvent(List<T> lstEntity, bool isSuccess);

        public delegate bool BeforeDeleteEvent(Expression<Func<T, bool>> predicate);

        public delegate void AfterDeleteEvent(Expression<Func<T, bool>> predicate, bool isSuccess);

        public delegate bool BeforeSaveOrUpdateEvent(T entity, bool isAdd);

        public delegate void AfterSaveOrUpdateEvent(T entity, bool isAdd, bool isSuccess);

        public delegate bool BeforeSaveOrUpdatingForListEvent(List<T> lstEntity, bool isAdd);

        public delegate bool AfterSaveOrUpdatingForListEvent(List<T> lstEntity, bool isAdd, bool isSuccess);

        public delegate bool BeforeCommitEvent();

        public delegate void AfterCommitEvent(bool isSuccess);

        public BeforeUpdateEvent BeforeUpdate { set; get; }

        public AfterUpdateEvent AfterUpdate { set; get; }

        public BeforeAddEvent BeforeAdd { get; set; }

        public AfterAddEvent AfterAdd { get; set; }

        public BeforeDeleteEvent BeforeDelete { get; set; }

        public AfterDeleteEvent AfterDelete { get; set; }

        public BeforeSaveOrUpdateEvent BeforeSaveOrUpdate { get; set; }

        public AfterSaveOrUpdateEvent AfterSaveOrUpdate { get; set; }

        public BeforeSaveOrUpdatingForListEvent BeforeSaveOrUpdatingForList { get; set; }

        public AfterSaveOrUpdatingForListEvent AfterSaveOrUpdatingForList { get; set; }

        public BeforeCommitEvent BeforeCommit { get; set; }

        public AfterCommitEvent AfterCommit { get; set; }

        private bool Updating(object arg)
        {
            Expression<Func<T, bool>> predicate = arg as Expression<Func<T, bool>>;
            if (BeforeUpdate != null)
                return BeforeUpdate(predicate);
            else
                return true;
        }

        private void Updated(object arg, bool isSuccess)
        {
            Expression<Func<T, bool>> predicate = arg as Expression<Func<T, bool>>;
            if (AfterUpdate != null)
                AfterUpdate(predicate, isSuccess);
        }

        private bool Adding(object arg)
        {
            List<T> lst = arg as List<T>;
            if (BeforeAdd != null)
                return BeforeAdd(lst);
            else
                return true;
        }

        private void Added(object arg, bool isSuccess)
        {
            List<T> lst = arg as List<T>;
            if (AfterAdd != null)
                AfterAdd(lst, isSuccess);
        }

        private bool Deleting(object arg)
        {
            Expression<Func<T, bool>> predicate = arg as Expression<Func<T, bool>>;
            if (BeforeDelete != null)
                return BeforeDelete(predicate);
            else
                return true;
        }

        private void Deleted(object arg, bool isSuccess)
        {
            Expression<Func<T, bool>> predicate = arg as Expression<Func<T, bool>>;
            if (AfterDelete != null)
                AfterDelete(predicate, isSuccess);
        }

        private bool SaveOrUpdating(object arg, bool isAdd)
        {
            var entity = arg as T;
            if (BeforeSaveOrUpdate != null)
                return BeforeSaveOrUpdate(entity, isAdd);
            else
                return true;
        }

        private void SaveOrUpdated(object arg, bool isAdd, bool isSuccess)
        {
            var entity = arg as T;
            if (AfterSaveOrUpdate != null)
                AfterSaveOrUpdate(entity, isAdd, isSuccess);
        }

        private bool SaveOrUpdatingForList(object arg, bool isAdd)
        {
            List<T> lstEntity = arg as List<T>;
            if (BeforeSaveOrUpdatingForList != null)
                return BeforeSaveOrUpdatingForList(lstEntity, isAdd);
            else
                return false;
        }

        private void SaveOrUpdatedForList(object arg, bool isAdd, bool isSuccess)
        {
            List<T> lstEntity = arg as List<T>;
            if (AfterSaveOrUpdatingForList != null)
                AfterSaveOrUpdatingForList(lstEntity, isAdd, isSuccess);
        }

        private bool Commintting()
        {
            if (BeforeCommit != null)
                return BeforeCommit();
            else
                return false;
        }

        private void Committed(bool isSuccess)
        {
            if (AfterCommit != null)
                AfterCommit(isSuccess);
        }


    }

ViewEntityDependent类

 public static class ViewEntityDependent
    {
        public static void RegisterEntityDependent()
        {
            JobView();
        }

        private static void JobView()
        {
            List<string> jobRecord = new List<string>()
            {
                "JobResumeAutonomy","JobResumeAttention","JobResumeCompanyAuto","JobResumeCompanyPut"
            };
            CacheDependentEntitySet.RegisterDependentEntity("JobRecord", jobRecord);
        }

    }