asp.net MVC5+EF+Autofac 关于泛型接口的继承与使用实现

之前在使用ef的时候为了省事就考虑了大量使用泛型接口来实现，在更新实体之后可以不用更新任何接口就可以实现增、删、改灯操作。

第一步：建立IDAL 负责连接entity 处理数据的接口，这里只简单写了几个，如果在实际运用中可以把所有操作数据的实现方法放在这里；

 

public  interface IDalBase<T> where T:class,new()
  {
      /// <summary>
      /// 过去所有数据的条数
      /// </summary>
      /// <returns></returns>
      Int64 GetCount();
        /// <summary>
        /// 根据条件获取所需条数
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
      Int64 GetCountWhere(Expression<Func<T,bool>> where);
        /// <summary>
        /// 根据条件加载数据
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
      IQueryable<T> LocaQueryable(Expression<Func<T, bool>> where);

      /// <summary>
      /// 分页查询
      /// </summary>
      /// <param name="indexpage">第几页开始</param>
      /// <param name="pagesize">页数</param>
      /// <param name="count">查询的数据条数</param>
      /// <param name="isdesc">是否降序</param>
      /// <param name="where">条件</param>
      /// <returns></returns>
      IQueryable<T> LocaPageQueryable(int indexpage,int pagesize,out int count,bool isdesc,Expression<Func<T,bool>> where);

       
  }

第二步：建立DAL数据操作实际方法实现类，这里注意继承泛型方式，期初因为功底不太扎实，在这里翻了几个跟斗，

DalBase<T>:IDAL.IDalBase<T> where T:class,new()

这里where T:class,new()要放在最后

第三步：建立IBLL数据处理的逻辑层，负责得到数据之后如何处理等方法的实现接口，注意看，都是泛型接口后期不用去调整的

 public interface IBLLBase<T> where T: class,new()
   {
       Int64 GetCount();
       IQueryable<T> LocaQueryable(Expression<Func<T,bool>> where);
       /// <summary>
       /// 更新
       /// </summary>
       /// <param name="model"></param>
       /// <returns></returns>
       T EditExpres(T model);
        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
       IQueryable<T> EditExpres(List<T> model);
        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
       T AddExpres(T model);

       IQueryable<T> AddExpres(List<T> model);
       bool DeleteExpres(T model);
       bool DeleteExpres(List<T> model);
       bool DeleteWhere(Expression<Func<T,bool>> where);
       bool DeleteSqlWhere(Expression<Func<T, bool>> where);

    }

第四步：建立BLL逻辑层实际实现方法类，这里的继承和DAL都差不多，只是继承了接口IBLL而已

public class BLLBase<T>: IBLL.IBLLBase<T> where T:class,new()
    {
       private IDAL.IDalBase<T> _db=new DalBase<T>();

        public T AddExpres(T model)
        {
            throw new NotImplementedException();
        }

        public IQueryable<T> AddExpres(List<T> model)
        {
            throw new NotImplementedException();
        }

        public bool DeleteExpres(T model)
        {
            throw new NotImplementedException();
        }

        public bool DeleteExpres(List<T> model)
        {
            throw new NotImplementedException();
        }

        public bool DeleteSqlWhere(Expression<Func<T, bool>> where)
        {
            throw new NotImplementedException();
        }

        public bool DeleteWhere(Expression<Func<T, bool>> where)
        {
            throw new NotImplementedException();
        }

        public T EditExpres(T model)
        {
            throw new NotImplementedException();
        }

        public IQueryable<T> EditExpres(List<T> model)
        {
            throw new NotImplementedException();
        }

        public Int64 GetCount()
        {
           return _db.GetCount();
        }

        public IQueryable<T> LocaQueryable(Expression<Func<T,bool>> where)
        {
            return _db.LocaQueryable(where);
        }

      
    }

第五步：建立AutoFacData，负责IOC反转，这里使用Autofac，映射逻辑和数据层、这里使用的都是泛型，直接可以在前端传需要反转的实体类来进行映射，我觉得这里还需要改进，希望大神们给个建议

/// <summary>
    /// 
    /// </summary>
    /// <typeparam name="TA">方法逻辑类</typeparam>
    /// <typeparam name="TB">公共方法</typeparam>
    /// <typeparam name="TC">公共方法接口</typeparam>
   public class AutoFacData<TA> where TA:class,new ()
    {
        public IDalBase<TA> AutoFac()
        {
            try
            {
            var builder = new ContainerBuilder();
                builder.RegisterGeneric(typeof(DalBase<>)).As(typeof(IDalBase<>));
                using (var container = builder.Build())
            {
                var manager = container.Resolve<IDalBase<TA>>();
               return manager;
            }

            }
            catch (Exception e)
            {
                return default(IDalBase<TA>);
            }
        }
        public IBLLBase<TA> AutoFacBLL()
        {
            try
            {
               
                var builder = new ContainerBuilder();
                builder.RegisterGeneric(typeof(BLLBase<>)).As(typeof(IBLLBase<>));
                using (var container = builder.Build())
                {
                    var manager = container.Resolve<IBLLBase<TA>>();
                    return manager;
                }

            }
            catch (Exception e)
            {
                return default(IBLLBase<TA>);
            }
        }
    }

第六步：实际使用，在控制器中请求数据，通过下面这个来实现映射获取逻辑层和数据层

 private readonly IBLLBase<mun> _mun=new Fac.AutoFacData<mun>().AutoFacBLL();

  public class HomeController : Controller
    {

        //映射
        private readonly IBLLBase<mun> _mun=new Fac.AutoFacData<mun>().AutoFacBLL();

        //public HomeController(IBLLBase<mun> mun)
        //{
        //    _mun =mun;
        //}
        public ActionResult Index()
        {
            var bll = _mun.LocaQueryable(p => true).ToList(); //new UserBll().getcount();
            return View();
        }

        public ActionResult About()
        {
            ViewBag.Message = "Your application description page.";

            return View();
        }

        public ActionResult Contact()
        {
            ViewBag.Message = "Your contact page.";

            return View();
        }
    }

这样实现后，在更新实体或者更新数据库结构，新增表等应该都很好维护了

 

作者：403648571@qq.com，QQ群：695080688