Entity Framework 第八篇 结构优化

 public class BaseRepository<TEntity> : IRepository, IDisposable where TEntity : class
    {
        private MyDbContext dbContext;

        public MyDbContext DbContext
        {
            get
            {
                return dbContext;
            }
            set
            {
                dbContext = value;
            }
        }

        private bool disposed;

        public BaseRepository()
        { }

        public BaseRepository(MyDbContext _dbContext)
        {
            this.dbContext = _dbContext;

        }

        #region 增删改查

        /// <summary>
        /// 新增实体对象
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="model"></param>
        /// <returns></returns>
        public int Insert(TEntity model)
        {
            return this.ChangeObjectState(model, EntityState.Added);
        }

        /// <summary>
        /// 新增实体对象集合
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="models"></param>
        /// <returns></returns>
        public int Insert(IEnumerable<TEntity> models)
        {
            return this.ChangeObjectState(models, EntityState.Added);
        }

        /// <summary>
        /// 持久化对象更改
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="model"></param>
        /// <returns></returns>
        public int Update(TEntity model)
        {
            return this.ChangeObjectState(model, EntityState.Modified);
        }

        /// <summary>
        /// 更新对象集合
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="models"></param>
        /// <returns></returns>
        public int Update(IEnumerable<TEntity> models)
        {
            return this.ChangeObjectState(models, EntityState.Modified);
        }

        /// <summary>
        /// 更新对象部分属性
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="predicate"></param>
        /// <param name="updateAction"></param>
        /// <returns></returns>
        public int Update(Expression<Func<TEntity, bool>> predicate, Action<TEntity> updateAction)
        {
            if (predicate == null)
                throw new ArgumentNullException("predicate");
            if (updateAction == null)
                throw new ArgumentNullException("updateAction");

            //dbContext.Configuration.AutoDetectChangesEnabled = true;
            var _model = dbContext.Set<TEntity>().Where(predicate).ToList();
            if (_model == null) return 0;
            _model.ForEach(p =>
            {
                updateAction(p);
                dbContext.Entry<TEntity>(p).State = EntityState.Modified;
            });
            return Save();
        }

        /// <summary>
        /// 删除实体对象
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="model"></param>
        /// <returns></returns>
        public int Delete(TEntity model)
        {
            return this.ChangeObjectState(model, EntityState.Deleted);
        }

        /// <summary>
        /// 删除实体对象集合
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="models"></param>
        /// <returns></returns>
        public int Delete(IEnumerable<TEntity> models)
        {
            return this.ChangeObjectState(models, EntityState.Deleted);
        }

        /// <summary>
        /// 删除实体对象集合（符合部分条件的）
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public int Delete(Expression<Func<TEntity, bool>> predicate)
        {
            List<TEntity> _list = null;

            _list = dbContext.Set<TEntity>().Where(predicate).ToList();
            foreach (var item in _list)
            {
                dbContext.Entry<TEntity>(item).State = EntityState.Deleted;
            }
            return Save();
        }


        public IList<TEntity> Search(Expression<Func<TEntity, bool>> predicate = null)
        {
            if (predicate == null)
            {
                return dbContext.Set<TEntity>().ToList();
            }
            else
            {
                return dbContext.Set<TEntity>().Where(predicate).ToList();
            }

        }

        /// <summary>
        /// 查询单个记录
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public TEntity SearchFirstOrDefault(Expression<Func<TEntity, bool>> predicate = null)
        {
            if (predicate == null)
            {
                return dbContext.Set<TEntity>().FirstOrDefault();
            }
            else
            {
                return dbContext.Set<TEntity>().Where(predicate).FirstOrDefault();
            }

        }

        /// <summary>
        /// 查询多笔记录
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public IList<TEntity> SearchList(Expression<Func<TEntity, bool>> predicate = null)
        {

            if (predicate == null)
            {
                return dbContext.Set<TEntity>().ToList();
            }
            else
            {
                return dbContext.Set<TEntity>().Where(predicate).ToList();
            }
        }

        public IList<TEntity> GetPaged(out int total, Expression<Func<TEntity, bool>> filter = null, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null, int index = 1, int size = 20)
        {
            int skipCount = (index - 1) * size;
            var query = Get(filter, orderBy);
            total = query.Count();
            query = skipCount > 0 ? query.Skip(skipCount).Take(size) : query.Take(size);
            return query.ToList();
        }

        public IList<TEntity> GetPaged(out int total, Expression<Func<TEntity, bool>> filter = null, string orderBy = null, int index = 1, int size = 20)
        {
            int skipCount = (index - 1) * size;
            var query = Get(filter, orderBy);
            total = query.Count();
            query = skipCount > 0 ? query.Skip(skipCount).Take(size) : query.Take(size);
            return query.ToList();
        }



        /// <summary>
        /// 执行带参数的sql语句，返回List
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="strsql"></param>
        /// <param name="paras"></param>
        /// <returns></returns>
        public IEnumerable<TEntity> GetList(string strsql, SqlParameter[] paras)
        {
            return dbContext.Database.SqlQuery<TEntity>(strsql, paras).ToList();
        }

        /// <summary>
        /// 执行不带参数的sql语句，返回list
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="strsql"></param>
        /// <returns></returns>
        public IEnumerable<TEntity> GetList(string strsql)
        {
            return dbContext.Database.SqlQuery<TEntity>(strsql).ToList();
        }

        /// <summary>
        ///  执行带参数的sql语句，返回一个对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="strsql"></param>
        /// <param name="paras"></param>
        /// <returns></returns>
        public TEntity GetOneEntity(string strsql, SqlParameter[] paras)
        {
            return dbContext.Database.SqlQuery<TEntity>(strsql, paras).Cast<TEntity>().First();
        }

        /// <summary>
        ///  执行不带参数的sql语句，返回一个对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="strsql"></param>
        /// <returns></returns>
        public TEntity GetOneEntity(string strsql)
        {
            return dbContext.Database.SqlQuery<TEntity>(strsql).Cast<TEntity>().First();
        }


        /// <summary>
        /// 执行带参数的sql语句，返回List
        /// </summary>
        /// <typeparam name="TView"></typeparam>
        /// <param name="strsql"></param>
        /// <param name="paras"></param>
        /// <returns></returns>
        public IEnumerable<TView> GetList<TView>(string strsql, SqlParameter[] paras)
        {
            return dbContext.Database.SqlQuery<TView>(strsql, paras).ToList();
        }

        /// <summary>
        /// 执行不带参数的sql语句，返回list
        /// </summary>
        /// <typeparam name="TView"></typeparam>
        /// <param name="strsql"></param>
        /// <returns></returns>
        public IEnumerable<TView> GetList<TView>(string strsql)
        {
            return dbContext.Database.SqlQuery<TView>(strsql).ToList();
        }

        /// <summary>
        ///  执行带参数的sql语句，返回一个对象
        /// </summary>
        /// <typeparam name="TView"></typeparam>
        /// <param name="strsql"></param>
        /// <param name="paras"></param>
        /// <returns></returns>
        public TView GetOneEntity<TView>(string strsql, SqlParameter[] paras)
        {
            return dbContext.Database.SqlQuery<TView>(strsql, paras).Cast<TView>().First();
        }

        /// <summary>
        ///  执行不带参数的sql语句，返回一个对象
        /// </summary>
        /// <typeparam name="TView"></typeparam>
        /// <param name="strsql"></param>
        /// <returns></returns>
        public TView GetOneEntity<TView>(string strsql)
        {
            return dbContext.Database.SqlQuery<TView>(strsql).Cast<TView>().First();
        }


        /// <summary>
        /// 获取查询数量
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="paras"></param>
        /// <returns></returns>
        public int GetCount(string sql, SqlParameter[] paras)
        {
            return dbContext.Database.SqlQuery(typeof(int), sql, paras).Cast<int>().First();
        }

        #endregion

        #region 私有方法


        private int Save()
        {
            int effect = 0;
            if (!this.dbContext.IsTransaction)
            {
                effect = this.dbContext.SaveChanges();
            }
            return effect;
        }


        /// <summary>
        /// 变更上下文管理器（对象）
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="model"></param>
        /// <param name="state"></param>
        private int ChangeObjectState(TEntity model, EntityState state)
        {
            //_context.Configuration.ValidateOnSaveEnabled = false; 
            dbContext.Entry<TEntity>(model).State = state;
            return Save();

        }

        /// <summary>
        /// 变更上下文管理器(对象集合)
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="model"></param>
        /// <param name="state"></param>
        private int ChangeObjectState(IEnumerable<TEntity> model, EntityState state)
        {
            if (model == null) return 0;

            //_context.Configuration.AutoDetectChangesEnabled = false;
            model.ToList().ForEach(p => dbContext.Entry<TEntity>(p).State = state);
            return Save();

        }


        public IQueryable<TEntity> Get(Expression<Func<TEntity, bool>> filter = null, string orderBy = null)
        {
            IQueryable<TEntity> query = dbContext.Set<TEntity>();
            if (filter != null)
            {
                query = query.Where(filter);
            }
            if (!string.IsNullOrEmpty(orderBy))
            {
                query = query.OrderBy(orderBy);
            }
            return query.AsQueryable();
        }

        public IQueryable<TEntity> Get(Expression<Func<TEntity, bool>> filter = null, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null)
        {
            IQueryable<TEntity> query = dbContext.Set<TEntity>();
            if (filter != null)
            {
                query = query.Where(filter);
            }
            if (orderBy != null)
            {
                orderBy(query).AsQueryable();
            }
            return query.AsQueryable();
        }


        #endregion



        public int ExecuteSqlCommand(string sql, params SqlParameter[] paras)
        {
            if (this.dbContext.IsTransaction)
            {
                if (dbContext.Database.CurrentTransaction == null)
                {
                    dbContext.Database.BeginTransaction();
                }
            }
            return dbContext.Database.ExecuteSqlCommand(sql, paras);
        }


        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }

        public virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    this.dbContext.Dispose();
                }
            }
            this.disposed = true;
        }
    }

 public class UserRepository : BaseRepository<S_Users>
    {

        public bool DelUserRoles(string id)
        {

 public class BaseBiz
    {
        protected MyDbContext DbContext = null;

        public BaseBiz()
        {
            DbContext = DbContextFactory.GetCurrentDbContext<XFDbContext>();
           
        }
    

 public class DbContextFactory
    {

        public static T GetCurrentDbContext<T>() where T : DbContext, new()
        {
            string name = typeof(T).Name;
            T dbContext = CallContext.GetData(name) as T;
            if (dbContext == null)
            {
                dbContext = new T();
                CallContext.SetData(name, dbContext);
            }
            return dbContext;
        }

      
    

 public class S_Users_Cls:BaseBiz
    {
        protected UserRepository UserRepository = null;

        public S_Users_Cls()
        {
            UserRepository = RepositoryFactory.CreateRepository<UserRepository>(this.DbContext);
        }

public class RepositoryFactory
    {
        private static Dictionary<Type, IRepository> Repositorys = new Dictionary<Type, IRepository>();

        private static object locker = new object();

        public static void Clear()
        {
            lock (locker)
            {
                Repositorys.Clear();
            }
        }

        public static bool Exists(Type key)
        {
            //T local;
            IRepository local;
            if (key == null)
            {
                return false;
            }
            return Repositorys.TryGetValue(key, out local);
        }

        public static IRepository Get(Type key)
        {
            IRepository local = null;
            if (key == null)
            {
                return null;
            }
            Repositorys.TryGetValue(key, out local);
            return local;
        }

        public static void Insert(Type key, IRepository value)
        {
            if ((key != null) && (value != null))
            {
                lock (locker)
                {
                    Repositorys[key] = value;
                }
            }
        }

        public static void Remove(Type key)
        {
            if (key != null)
            {
                lock (locker)
                {
                    Repositorys.Remove(key);
                }
            }
        }

        public static T CreateRepository<T>(MyDbContext myDbContext) where T : class,IRepository, new()
        {
            Type key=typeof(T);
            T repository = default(T);
            if (Exists(key) && Get(key) != null)
            {
                 repository = (T)Get(key);
            }
            else
            {
                 repository = new T();
                 Insert(key,repository);
            }
            repository.DbContext = myDbContext;
            return (T)repository;
        }
    }

 public class MyDbContext : DbContext, ITransaction
    {
       public MyDbContext(string connectionString)
            : base(connectionString)
        {
            // 是否启动延迟加载
            Configuration.LazyLoadingEnabled = false;
            // 是否启动代理
            Configuration.ProxyCreationEnabled = false;
            Configuration.AutoDetectChangesEnabled = false;
            Configuration.ValidateOnSaveEnabled = false;
        }

        public void BeginTransaction()
        {
            this.IsTransaction = true;
        }

        public int Commit()
        {
            int reault = this.SaveChanges();
            this.IsTransaction = false;
            DbContextTransaction transaction = this.Database.CurrentTransaction;
            if (transaction != null)
            {
                transaction.Commit();
                transaction.Dispose();
                reault += 1;
            }
            return reault;
        }

        public void Rollback()
        {
            this.IsTransaction = false;
            DbContextTransaction transaction = this.Database.CurrentTransaction;
            if (transaction != null)
            {
                transaction.Rollback();
                transaction.Dispose();
            }
        }

        private bool isTransaction = false;


        public bool IsTransaction
        {
            get { return isTransaction; }
            set { this.isTransaction = value; }
        }

    }

public class XFDbContext : MyDbContext
    {
        public XFDbContext()
            : base("XFJD")
        {
            // 防止Entity变更导致数据库自动更新
            Database.SetInitializer<XFDbContext>(null);
        }

   public bool Add(S_Users model)
        {
          
            bool result = false;
            this.DbContext.BeginTransaction();
            try
            {
                this.UserRepository.Insert(model);

int effect = this.DbContext.Commit();
                result = effect > 0;
            }
            catch (Exception ex)
            {
                this.DbContext.Rollback();
            }
            return result;
        }

  public bool EditPwd(S_Users model)
        {
            return UserRepository.EditPwd(model);
        }