.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; }

    }

巴特西

.netCore2.0 依赖注入

最新文章

热门文章