首页 > > 网络编程 > Asp.Net编程 >

ASP.NET MVC 中 Autofac依赖注入DI 控制反转IOC …

2018-06-22 06:20:10来源：未知阅读 ()

先简单了解一这个几个名词的意思。

控制反转(IOC) 依赖注入(DI) 并不是某种技术。而是一种思想。一种面向对象编程法则

什么是控制反转(IOC)? 什么是依赖注入(DI)

可以点击下面链接理解的比较详细

https://blog.csdn.net/PacosonSWJTU/article/details/52786216

https://www.cnblogs.com/Mr-Rocker/p/7721824.html

控制反转（IOC）

在之前传统应用程序我们都是在类内部主动实例化依赖对象，从而导致类与类之间高耦合，难于测试

可以看到下图类与类之间依赖关系很紧密

（图是我盗的。感谢做这个图的大佬）

IOC 就是一种容器把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

IOC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

依赖注入(DI)

依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台

依赖谁？依赖于IOC容器

注入谁？由IoC容器注入应用程序某个对象，应用程序依赖的对象；

被依赖者并不是有依赖者主动去初始化而是有提供资源的外部创建者决定

两者关系也就是被注入对象依赖IoC容器配置依赖对象

说到DI IOC 就有必要了解下现在用的最多的AutoFac

首先在项目中引入 AutoFac 如果你是WebAPI 你可以输入 AutoFac.WebApi2

我定义了两个仓储类 IRepositoryBase 和 RepositoryBase 主要用于操作数据库的各种方法

  public interface IRepositoryBase<T> where T:class
    {

        IQueryable<T> FindAll();

        T FindSingle(Expression<Func<T, bool>> exp = null);

        T Find(int id);

        IQueryable<T> Find(Expression<Func<T, bool>> exp = null);

        /// <summary>
        /// Linq表达式树查询分页
        /// </summary>
        /// <returns></returns>
        IQueryable<T> Find(int pageindex = 1, int pagesize = 10, Expression<Func<T, bool>> exp = null);

        /// <summary>
        /// 得到受影响条数
        /// </summary>
        /// <returns></returns>
        int GetCount(Expression<Func<T, bool>> exp = null);

        void Add(T entity);

        void AddBatch(T[] entitys);

        void AddBatch(List<T> entitys);

        /// <summary>
        /// 更新实体所有属性
        /// </summary>
        /// <returns></returns>
        void Update(T entity);

        void Delete(T entity);


        /// <summary>
        /// 按指定的ID进行批量更新
        /// </summary>
        void Update(Expression<Func<T, object>> identityExp,T entity);

        T Update(T entity,int id);

        /// <summary>
        /// 批量删除
        /// </summary>
        void Delete(Expression<Func<T, bool>> exp);

        void Save();

        int ExecuteSql(string sql);
    }

继承接口并实现

public class RepositoryBase<T> : IRepositoryBase<T> where T:class
    {
        protected OpenSPDBContext openSPDBContext = new OpenSPDBContext();

         public void Add(T entity)
        {
            openSPDBContext.Set<T>().Add(entity);
            Save();
        }

        public void AddBatch(T[] entitys)
        {
            openSPDBContext.Set<T>().AddRange(entitys);
            Save();
        }

        public void Delete(Expression<Func<T, bool>> exp)
        {
           var entitys= openSPDBContext.Set<T>().Where(exp);
            openSPDBContext.Set<T>().RemoveRange(entitys);
        }

        public void Delete(T entity)
        {
            openSPDBContext.Set<T>().Remove(entity);
            Save();
        }

        public int ExecuteSql(string sql)
        {
            return openSPDBContext.Database.ExecuteSqlCommand(sql);
        }

        public IQueryable<T> Find(Expression<Func<T, bool>> exp = null)
        {
            return Filter(exp);
        }

        public T Find(int id)
        {
          return openSPDBContext.Set<T>().Find(id);
        }

        public IQueryable<T> Find(int pageindex, int pagesize, Expression<Func<T, bool>> exp = null)
        {

            return Filter(exp).Skip(pagesize * (pageindex - 1)).Take(pagesize);
        }


        public IQueryable<T> FindAll()
        {
            return openSPDBContext.Set<T>();
        }

        public T FindSingle(Expression<Func<T, bool>> exp = null)
        {
            return openSPDBContext.Set<T>().AsNoTracking().FirstOrDefault(exp);
        }

        public int GetCount(Expression<Func<T, bool>> exp = null)
        {
            return Filter(exp).Count();
        }

        public void Update(T entity)
        {
            openSPDBContext.Entry(entity).State = EntityState.Modified;
            Save();
        }

        /// <summary>
        /// 按指定id更新实体,会更新整个实体
        /// </summary>
        /// <param name="identityExp">The identity exp.</param>
        /// <param name="entity">The entity.</param>
        public void Update(Expression<Func<T, object>> identityExp, T entity)
        {
            openSPDBContext.Set<T>().AddOrUpdate(identityExp, entity);
        }

        public IQueryable<T> Filter(Expression<Func<T,bool>> exp)
        {
            var dbset = openSPDBContext.Set<T>().AsQueryable();
            if (exp != null)
            dbset = dbset.Where(exp);

            return dbset;

        }

        public void Save()
        {
            try
            {
                openSPDBContext.SaveChanges();
            }
            catch (DbEntityValidationException e)
            {
                throw new Exception(e.EntityValidationErrors.First().ValidationErrors.First().ErrorMessage);
                throw;
            }
        }

        public void AddBatch(List<T> entitys)
        {
            openSPDBContext.Set<T>().AddRange(entitys);
        }

        public T Update(T entity, int id)
        {
            openSPDBContext.Entry(entity).State = EntityState.Modified;
            Save();
            return openSPDBContext.Set<T>().Find(id);
        }   
    }

然后在全局类中注册依赖配置

我新建了个逻辑处理层 Server 用来方便控制调用这里我依赖了IRepositoryBase<T>

public class ShopingServer : IShopingServer
    {
        private IRepositoryBase<ShopingInfo> _shopingRepository;
        public ShopingServer(IRepositoryBase<ShopingInfo> shopingRepository)
        {
            _shopingRepository = shopingRepository;
        }

        public IQueryable<ShopingInfo> GetAll()
        {
           var ss = _shopingRepository.FindAll();
            return ss;
        }
    }