一个简单实用的,基于EF的三层架构

到底什么样的框架才是好框架呢?或许不同人有不同的看法.我个人觉一个好的框架, 最重要的要是简单实用,能快速适开发,可维护性高(不会出现复制黏贴的代码),并能快速响应各种业务场景的变化的框架,同时性能不会太差.我觉的这样的框 架,就是一个好的框架.而且,我觉的做框架,千万不能设计过度,不然会得不偿失.最关键要看你的业务场景,千万不要因为模式而模式,更多的看考虑它的实用 性. 就像我接触的我们公司一个基于EF的三层,架构,我就觉得里面有一些不好的设计.主要表现如下.

1. 每个类的一些基本的操作,如增加修改,删除.都是通过代码生成器生成的.其实我是很反对用代码生成器的.用代码生成的代码,就相当于我们在写代码中,进行复制黏贴.这个在我们设计上是很杜绝的. 我们以前做项目,都是不用代码生成器.用代码生成器,只会生成那个实体类.
2. Bll层和DAL层,职责不分明.我看我做的那项目,写的代码比较乱.有些把业 务层的东西,写在dal层. 这个也是框架的问题导致,因为bll层,没有事务,所以把事务里面的业务,也写在dal层里.同时有些人也为了方便,把访问数据的逻辑都放在bll层. 总之让人感觉很混乱.
3. 是用IOC技术,把所有的bll层,dal层都是基于接口的方式去实现.到现在 为止,我都觉的这个东西有点设计过度了.因为大部分项目,都不会去换dal层,bll层.如果硬要把所有的bll层,dal层都用IOC来做,会带来如下 问题.(1) 我们想增加一个方法,经常要在4个地方写函数. (2)想用F12跟进去查看代码,是跟不进去的.只能跟到接口那里.  (3)最要命的就是它那个报错.经常会报配置错误,其实一查根本不是配置错误.只是生成的类有问题

  其实EF框架,还是很好用的,尤其在快速开发上,有不可替代的优势.而且性能上,我也做过压力测试,跟ado.net,差不了多少.因此,我就想开发一个基于EF的三层架构,请看下面的相关类图.
 

该框架,主要实现如下功能.

1. 所有的dal层和bll层都有个基类,在基类里把所有的基本操作封装起来.
2. 在dal层里,并没有真正的操作数据库,只是根据ef生成相应的语句,真正执行是在bll层里.
3. 在bll层里有context对象,用来是控制bll层里的事务.
4. Service层,是用来给外部提供系统调用的,可以是wcf,也可以webservice,也可以webapi 的方式.
5. Web 层可的数据,可以来自bll层,也可以来自service层.(在案例中还没有实现)

我觉的我这框架的优点和缺点,我将下次再介绍,有兴趣的朋友,可以先下载代码来看看.同时也欢迎各位朋友评价这框架..

下载路径  http://pan.baidu.com/share/link?shareid=464738&uk=3322219884

同时,我也提供一些实现的代码,供大家参考

dal层

using Architecture.Mode;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Objects;
using System.Data.Objects.DataClasses;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace Architecture.DAL
{
    public class BaseDAL<T> : IDisposable where T : EntityObject
    {
        public IContext Context;
        private Entities db;
        private bool isSetDB;
        public BaseDAL()
        {
            ENContext context = new ENContext();
            this.Context = context;
            this.db = context.db;
            isSetDB = false;
            updateChange();
        }

        public BaseDAL(IContext context)
        {
            this.Context = context;
            var context1 = context as ENContext;
            if (context1.db == null) throw new Exception("初始化时,上下文为空");
            this.db = context1.db;
            isSetDB = true;
            updateChange();
        }

        private void updateChange()
        {
            //对公共字段的统一修改.
            this.db.SavingChanges += new EventHandler(changing);
        }

        private void changing(object o, EventArgs e)
        {
            Entities ec = o as Entities;
            if (ec != null)
            {
                //增加的
                foreach (ObjectStateEntry entry in ec.ObjectStateManager.GetObjectStateEntries(EntityState.Added))
                {

                    Type t = entry.Entity.GetType();
                    var property = t.GetProperty("CreationUser");
                    if(property!=null) property.SetValue(entry.Entity, "test");
                    property = t.GetProperty("ModificationUser");
                    if (property != null) property.SetValue(entry.Entity, "test");
                    property = t.GetProperty("CreationDate");
                    if (property != null) property.SetValue(entry.Entity, System.DateTime.Now);
                    property = t.GetProperty("ModificationDate");
                    if (property != null) property.SetValue(entry.Entity, DateTime.Now);
                    property = t.GetProperty("Status");
                    if (property != null) property.SetValue(entry.Entity, 1);
                }

                //修改的
                foreach (ObjectStateEntry entry in ec.ObjectStateManager.GetObjectStateEntries(EntityState.Modified))
                {

                    Type t = entry.Entity.GetType();                 
                    var property = t.GetProperty("ModificationUser");
                    if (property != null) property.SetValue(entry.Entity, "test");           
                    property = t.GetProperty("ModificationDate");
                    if (property != null) property.SetValue(entry.Entity, DateTime.Now);
                  
                }
            }
        }

        //添加
        public T AddEntity(T entity)
        {
            db.CreateObjectSet<T>().AddObject(entity);
            // db.Entry<T>(entity).State = EntityState.Added;
            //db.SaveChanges();
            return entity;
        }

        //修改
        public bool UpdateEntity(T entity)
        {

            if (entity.EntityKey != null)
            {
                // entity.EntityKey = null;
               // entity.
              //  db.Attach(entity);
               // db.ObjectStateManager.ChangeObjectState(entity, EntityState.Modified);
            }
            else
            {
                db.CreateObjectSet<T>().Attach(entity);
                db.ObjectStateManager.ChangeObjectState(entity, EntityState.Modified);
            }
            return true;
            //db.Set<T>().Attach(entity);
            //db.Entry<T>(entity).State = EntityState.Modified;
            //  return db.SaveChanges() > 0;

        }

        /// <summary>
        /// 批量修改
        /// </summary>
        /// <param name="where"></param>
        /// <param name="updater"></param>
        /// <returns></returns>
        public int UpdateEntitiesWhere(Expression<Func<T, bool>> where, Expression<Func<T>> updater)
        {
            return db.CreateObjectSet<T>().Update(where, updater);
        }

        //删除
        public bool DeleteEntity(T entity)
        {
            if (entity.EntityKey == null)
            {
                db.CreateObjectSet<T>().Attach(entity);
            }
            db.ObjectStateManager.ChangeObjectState(entity, EntityState.Deleted);
            return true;
            // db.Set<T>().Attach(entity);
            //db.Entry<T>(entity).State = EntityState.Deleted;
            //return db.SaveChanges() > 0;

        }

        /// <summary>
        /// 批量删除
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        public int DeleteEntitiesWhere(Expression<Func<T, bool>> where)
        {
            return db.CreateObjectSet<T>().Delete(where);
        }


        public T GetEntityByID(object id)
        {
            Type t = typeof(T);
            string tableName=t.Name;
            string sql = string.Format("select * from {0} where id=@p0", tableName);
           var ent= db.ExecuteStoreQuery<T>(sql, id).FirstOrDefault();
           if (ent != null)
               db.CreateObjectSet<T>().Attach(ent);
           return ent;
        }

        /// <summary>
        /// 查询实体
        /// </summary>
        /// <param name="where">条件</param>
        /// <param name="includes">预加载的词</param>
        /// <returns></returns>
        public IQueryable<T> GetEntities(Expression<Func<T, bool>> where,params string[] includes)
        {
           //预加载
            if (includes != null && includes.Length > 0)
            {
                var dbEntities = db.CreateObjectSet<T>().Include(includes[0]);
                bool isFirst = true;
                foreach (string include in includes)
                {
                    if (isFirst)
                        isFirst = false;
                    else
                    {
                        dbEntities = dbEntities.Include(include);
                    }
                }
                return dbEntities.Where(where);
            }
            else
            {
                return db.CreateObjectSet<T>().Where(where);
            }
            //return db.Set<T>().Where<T>(wherelambda).AsQueryable();
        }
      
        /// <summary>
        /// 根据分页取查询条件
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="where"></param>
        /// <param name="orderByProperty"></param>
        /// <param name="isAscendingOrder"></param>
        /// <param name="total"></param>
        /// <param name="includes"></param>
        /// <returns></returns>
        public IQueryable<T> GetEntitiesByPage<TResult>(int pageIndex, int pageSize, Expression<Func<T, bool>> where, Expression<Func<T, TResult>> orderByProperty, bool isAscendingOrder, ref int total, params string[] includes)
        {
            var list = GetEntities(where,includes);
            return list.Page(pageIndex, pageSize, orderByProperty, isAscendingOrder, ref total);
        }



        public void Dispose()
        {
            if (this.Context != null&&!isSetDB)
                this.Context.Dispose();
        }
    }
}

bll层

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Architecture.DAL;
using System.Linq.Expressions;
using System.Data.Objects.DataClasses;

namespace Architecture.BLL
{
    public class BaseBLL<T>:IDisposable where T : EntityObject 
                              //  where DAL:BaseDAL<T>,new()
    {
       // protected DAL myDal = new DAL();
        protected BaseDAL<T> myDal = new BaseDAL<T>();
        protected IContext Context
        {
            get
            {
              return  myDal.Context;
            }
        }
        public T AddEntity(T entity)
        {
           // using (var dal = new BaseDAO<T>())
            {
                myDal.AddEntity(entity);
                myDal.Context.SaveChanges();
                return entity;
            }
        }

        //修改
        public bool UpdateEntity(T entity)
        {
          //  using (var dal = new BaseDAO<T>())
            {
                myDal.UpdateEntity(entity);
               return myDal.Context.SaveChanges()>0;               
            }
        }

        /// <summary>
        /// 批量修改
        /// </summary>
        /// <param name="where"></param>
        /// <param name="updater"></param>
        /// <returns></returns>
        public int UpdateEntitiesWhere(Expression<Func<T, bool>> where, Expression<Func<T>> updater)
        {
            return myDal.UpdateEntitiesWhere(where, updater);
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public bool DeleteEntity(T entity)
        {
          //  using (var dal = new BaseDAO<T>())
            {
                
                myDal.DeleteEntity(entity);
                return myDal.Context.SaveChanges() > 0;
            }
        }

        public int DeleteEntitiesWhere(Expression<Func<T, bool>> where)
        {
            return myDal.DeleteEntitiesWhere(where);
        }

  
        ////查询
        public IList<T> GetEntities(Expression<Func<T, bool>> where,params string[] includes)
        {
          //  using (var dal = new BaseDAO<T>())
            {
                return myDal.GetEntities(where,includes).ToList<T>();
            }
        }

        public T GetEntityByID(object id)
        {
            return myDal.GetEntityByID(id);
        }

        ////分页
        public IList<T> GetEntitiesByPage<TResult>(int pageIndex, int pageSize, Expression<Func<T, bool>> where, Expression<Func<T, TResult>> orderByProperty, bool isAscendingOrder, ref int total, params string[] includes)
        {
          //  using (var dal = new BaseDAO<T>())
            {
                return myDal.GetEntitiesByPage(pageIndex,pageSize, where,orderByProperty,isAscendingOrder,ref total,includes).ToList<T>();
            }
        }

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

    //public class BaseBLL<T> : BaseBLL<T, BaseDAL<T>>, IDisposable where T : EntityObject
    //{
    //}
}