.netCore2.0 依赖注入

依赖注入（ID）是一种实现对象及其合作者或者依赖想之间松散耦合的技术
对于传统的方法来说，获取类的方法通常用new如下

public class DIController : Controller
    {
        public IActionResult Index()
        {
            MyServices my = new MyServices();
            my.getName();
            return View();
        }
    }

但是问题来了，如果我后期要修改MyServices类的时候，就需要在整个项目中来搜索修改

一：接口注入

为了实现解耦，我们需要建立IServices的接口，然后类实现接口，在控制器中进行构造函数，初始化接口，然后使用接口来进行操作，这样就达到了解耦的目的，俗称依赖注入

具体类代码如下

namespace CoreWeb2.Services
{
    public class MyServices:IServices
    {
        public string getName()
        {
            return "张三";
        }
    }
    public class OServices:IServices
    {
        public string getName()
        {
            return "李四";
        }
    }
    public interface IServices {
        string getName();
    }
}

控制器代码如下：

namespace CoreWeb2.Controllers
{
    public class DIController : Controller
    {
        /// <summary>
        /// 通过构造函数初始化接口
        /// 在外界使用时候直接new出具体类，这样就达到了程序解耦的目的，俗称依赖注入
        /// </summary>
        public IServices _services;
        public DIController(IServices services)
        {
            this._services = services;
        }
        public IActionResult Index()
        {
            //通过接口调用
            _services.getName();
            return View();
        }
    }
}

但是问题又来了，因为控制器默认构造函数是一个无参的，现在增加了参数传递，直接访问会报错误，因而就需要在Startup.cs中的ConfigureServices方法中进行程序注入，将构造函数的参数注入到容器中，当程序访问时会自动在容器中找参数，才可以使用

依赖注入有三种方式：

1、AddTransient

　　每个请求创建一个

2、AddScoped

　　一个域创建一个

3、AddSingleton

　　单例，整个应用程序生命周期以内只创建一个实例 

//每个请求创建一个
            services.AddTransient<IServices, MyServices>();
            //一个域创建一个
            services.AddScoped<IServices, MyServices>();
            //单例，整个应用程序生命周期以内只创建一个实例
            services.AddSingleton<IServices, MyServices>();

当程序进行依赖注入后，控制器中就可以访问到当前的实例对象了，

 二：泛型注入

泛型接口

/// <summary>
    /// 数据仓储
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public interface IRepository<TEntity> where TEntity : class
    {
        DbContext DbContext { get; }

        DbSet<TEntity> Entities { get; }
        IQueryable<TEntity> Table { get; }
        TEntity GetById(object id);
        void Insert(TEntity engine, bool isSave = true);
        void Update(TEntity engine, bool isSave = true);
        void Delete(TEntity engine, bool isSave = true);
    }

泛型接口实现

  public class EfRepository<TEntity> : IRepository<TEntity> where TEntity:class
    {
        private GeneralDbContext _dbContext;
        public EfRepository(GeneralDbContext generalDbContext)
        {
            _dbContext = generalDbContext;
        }

        public DbContext DbContext => _dbContext;

        public DbSet<TEntity> Entities => _dbContext.Set<TEntity>();

        public IQueryable<TEntity> Table => Entities;

        public void Delete(TEntity engine, bool isSave = true)
        {
            Entities.Remove(engine);
            if (isSave)
            {
                _dbContext.SaveChanges();
            }
        }

        public TEntity GetById(object id)
        {
            return _dbContext.Set<TEntity>().Find(id);
        }

        public void Insert(TEntity engine, bool isSave = true)
        {
            Entities.Add(engine);
            if (isSave)
            {
                _dbContext.SaveChanges();
            }
        }

        public void Update(TEntity engine, bool isSave = true)
        {
            Entities.Update(engine);
            if (isSave)
            {
                _dbContext.SaveChanges();
            }
        }

泛型注入方式

  //将泛型注入 services.AddScoped(typeof(IRepository<>),typeof(EfRepository<>)); 

关联类GeneralDbContext

 public class GeneralDbContext : DbContext
    {
        public GeneralDbContext(DbContextOptions options) : base(options)
        { }
        public DbSet<Category> Categorys{ get; set; }
    }