什么是依赖和耦合

不同的类与对象，执行不同的功能，大家分工合作，各司其职。
在代码世界里，这个合作，有个术语，叫做【依赖】，依赖的同时就出现了耦合，依赖越直接，耦合越紧密

这个代码就是紧耦合，Car完全是依赖在Engine上的。Engine出问题，Car完蛋。 如果十个人开发，其中9个人的代码都依赖另一个人的代码才能运行，要是那个人没开发好，代码bug，9个人都完蛋。 所以开发时，尽可能避免紧耦合

  1. namespace ConsoleApp2
  2. {
  3.     //引擎 
  4.    class Engine
  5.     {
  6.         public int RPM { get; private set; }//发动机每分钟多少转
  7.         public void Work(int gas)
  8.         {
  9.             this.RPM = 1000 * gas;
  10.         }
  11.     }
  12.     //汽车
  13.     class Car
  14.     {
  15.         private Engine engine;
  16.         public int Speed { get; private set; }
  17.         public Car(Engine engine)//创建实例时，必须给个引擎，没有引擎哪叫车
  18.         {
  19.             this.engine = engine;
  20.         }
  21.         public void Run(int gas) 
  22.         {
  23.             this.engine.Work(gas);
  24.             this.Speed = this.engine.RPM / 100;
  25.         }
  27.     }
  28. }
  1. namespace ConsoleApp2
  2. {
  3.     class Program
  4.     {
  5.         static void Main(string[] args)
  6.         {
  7.             Engine engine = new Engine();
  8.             Car car = new Car(engine);
  9.             car.Run(3);
  10.             Console.WriteLine(car.Speed);
  11.         }
  13.     }
  14. }

依赖倒置（DIP）

  1. 高层次的模块不应该依赖低层次的模块，两者都应该依赖其抽象。

    高层模块不应该直接依赖低层模块的具体实现，而是应该依赖于低层模块的抽象，也就是说，模块之间的依赖是通过抽象发生的，实现类之间不应该发生直接的依赖关系，他们的依赖关系应该通过接口或者抽象类产生。 比如上面的汽车引擎案例：高层模块Car，低层模块Engine，不应该Car依赖具体的Engine对象，应该依赖Engine的抽象基类或者接口。

  2. 抽象不应该依赖于具体，具体应该依赖于抽象。

    接口或者抽象类不应该依赖于实现类。举个例子，假如我们要写xxx类代码，直接就去实现了功能，等到开发完成以后发现没有使用依赖倒置原则，这时候在根据实现类去写接口，这种是不对的，应该首先设计抽象，然后在根据抽象去实现，应该要面向接口编程。先写接口或者抽象类，在写实现或者子类，这叫设计。反过来叫重构。

通过接口实现依赖倒置

  1. namespace ConsoleApp2
  2. {
  3.     interface IPhone
  4.     {
  5.         void Dail();//拨号
  6.         void PickUp();//接电话
  7.         void Send();//发短信
  8.         void Receive();//收短信
  9.     }
  11.     class Nokia : IPhone
  12.     {
  13.         public void Dail()
  14.         {
  15.             Console.WriteLine("洛基亚打电话");
  16.         }
  18.         public void PickUp()
  19.         {
  20.             Console.WriteLine("洛基亚接电话");
  21.         }
  23.         public void Receive()
  24.         {
  25.             Console.WriteLine("洛基亚收短信");
  26.         }
  28.         public void Send()
  29.         {
  30.             Console.WriteLine("洛基亚发短信");
  31.         }
  32.     }
  34.     class HaWei : IPhone
  35.     {
  36.         public void Dail()
  37.         {
  38.             Console.WriteLine("华为打电话");
  39.         }
  41.         public void PickUp()
  42.         {
  43.             Console.WriteLine("华为接电话");
  44.         }
  46.         public void Receive()
  47.         {
  48.             Console.WriteLine("华为收短信");
  49.         }
  51.         public void Send()
  52.         {
  53.             Console.WriteLine("华为发短信");
  54.         }
  55.     }
  57.     class PhoneUser
  58.     {
  59.         private IPhone phone;
  60.         public PhoneUser(IPhone phone)
  61.         {
  62.             this.phone = phone;
  63.         }
  64.         public void UsePhone()
  65.         {
  66.             phone.Dail();
  67.             phone.PickUp();
  68.             phone.Send();
  69.             phone.Receive();
  70.         }
  71.     }
  72. }
  1. namespace ConsoleApp2
  2. {
  3.     class Program
  4.     {
  5.         static void Main(string[] args)
  6.         {
  7.             PhoneUser phoneUser = new PhoneUser(new Nokia());
  8.             phoneUser.UsePhone();
  10.             //如果用户的洛基亚手机坏了，直接一个手机，换成华为的
  11.             phoneUser = new PhoneUser(new HaWei());
  12.             phoneUser.UsePhone();
  14.             //只要PhoneUser里面的逻辑没问题，如果手机对象的逻辑出问题了，换一个手机对象。
  15.             //不用修改PhoneUser里面的代码，用接口实现了多态,解耦合
  16.         }
  18.     }
  19. }

控制反转（IOC）

控制反转(IOC)：Inversion of Control的缩写，一种反转流、依赖和接口的方式，它把传统上由程序代码直接操控的对象的控制器（创建、维护）交给第三方，通过第三方（IOC容器）来实现对象组件的装配和管理。
IOC容器，也可以叫依赖注入框架，是由一种依赖注入框架提供的，主要用来映射依赖，管理对象的创建和生存周期。IOC容器本质上就是一个对象，通常会把程序里面所有的类都注册进去，使用这个类的时候，直接从容器里面去解析。

依赖注入（DI）

依赖注入(DI)：Dependency Injection的缩写。依赖注入是控制反转的一种实现方式，依赖注入的目的就是为了实现控制反转。
依赖注入是一种工具或手段，目的是帮助我们开发出松耦合、可维护的程序。

演示类

关于这个演示类，看接口文章

  1. namespace ConsoleApp2
  2. {
  3.     //交通工具接口
  4.     interface IVehicle
  5.     {
  6.         void Run();
  7.     }
  8.     //武器接口
  9.     interface IWeapon
  10.     {
  11.         void Fire();
  12.     }
  13.     //飞行接口
  14.     interface IFly
  15.     {
  16.         void Fly();
  17.     }
  18.     //坦克接口，实现了交通工具的功能，还实现了武器的功能
  19.     interface ITank:IVehicle,IWeapon
  20.     {
  22.     }
  23.     //战斗机接口
  24.     interface IFighter : IVehicle, IWeapon, IFly
  25.     {
  27.     }
  28.     //汽车
  29.     class Car : IVehicle
  30.     {
  31.         public void Run()
  32.         {
  33.             Console.WriteLine("汽车跑");
  34.         }
  35.     }
  36.     //坦克
  37.     class Tank : ITank
  38.     {
  39.         public void Fire()
  40.         {
  41.             Console.WriteLine("坦克开火");
  42.         }
  44.         public void Run()
  45.         {
  46.             Console.WriteLine("坦克跑");
  47.         }
  48.     }
  49.     //战斗机
  50.     class Fighter : IFighter
  51.     {
  52.         public void Fire()
  53.         {
  54.             Console.WriteLine("飞机开火");
  55.         }
  57.         public void Fly()
  58.         {
  59.             Console.WriteLine("飞机飞");
  60.         }
  62.         public void Run()
  63.         {
  64.             Console.WriteLine("飞机跑");
  65.         }
  66.     }
  67.     //驾驶人
  68.     class Person
  69.     {
  70.         //只要一个交通工具,不管是车，坦克还是飞机。IVehicle是这些的基接口
  71.         private IVehicle vehicle;
  72.         public Person(IVehicle vehicle)
  73.         {
  74.             this.vehicle = vehicle;
  75.         }
  76.         public void Drive()
  77.         {
  78.             //我只需要跑的功能
  79.             vehicle.Run();
  80.         }
  81.         public void Attack()
  82.         {
  83.             //如果要使用Fire，接口就不能是基接口IVehicle了，因为他没有，得是IWeapon
  84.             //凡是继承了IWeapon接口的都能用
  85.         }
  86.     }
  87. }

安装框架

依赖注入 要用 依赖注入框架，框架很多，这里使用其中一个

NuGet搜索：DependencyInjection

image.png

引入名称空间

  1. using Microsoft.Extensions.DependencyInjection;

创建依赖注入

创建依赖注入程序只用执行一次，但是要使用，sp一定要在一个公共的能访问都的地方

  1. static void Main(string[] args)
  2. {
  3.     //创建一个服务的提供者容器
  4.     var sc = new ServiceCollection();
  5.     //往容器里面装东西,参数1：基接口类型，参数2：实现类类型,创建依赖关系
  6.     sc.AddScoped(typeof(IWeapon), typeof(Tank));
  7.     //注册,要使用依赖注入，sp一定是要能访问到地方
  8.     var sp = sc.BuildServiceProvider();
  9. }

简单使用依赖注入

  1. static void Main(string[] args)
  2. {
  3.     //创建一个服务的提供者容器
  4.     var sc = new ServiceCollection();
  5.     //往容器里面装东西,参数1：基接口类型，参数2：实现类类型
  6.     sc.AddScoped(typeof(IWeapon), typeof(Tank));
  7.     //注册
  8.     var sp = sc.BuildServiceProvider();
  10.     //----------------------------------------
  11.     //使用依赖注入
  12.     //从容器里面取出一个添加的对象，基接口类型，引用的是实现类的对象
  13.     //这样就获取了一个tank对象，能只能tank对象的一切功能
  14.     IWeapon tank = sp.GetService<IWeapon>();
  15.     tank.Fire();
  16. }

使用依赖注入的好处

如果一个项目很多个文件里面创建了很多个 new Tank();对象。如果需求改变了，不要Tank了，全部改成Fighter。那只能去一个一个把new Tank();改成new Fighter();了。

用了依赖注入，反正接收的类型都是IWeapon，Tank和Fighter的基接口。直接改变ServiceCollection里面的参数后，凡是使用这个依赖注入的地方，都变成了，我改变的那个

  1. static void Main(string[] args)
  2. {
  3.     var sc = new ServiceCollection();
  4.     sc.AddScoped(typeof(IWeapon), typeof(Fighter));
  5.     var sp = sc.BuildServiceProvider();
  7.     //----------------------------------------
  8.     //变量名我都懒得改，我只改了上面的Fighter，其他都没动。
  9.     //整个代码中sp.GetService<IWeapon>()的都变成了战斗机
  10.     IWeapon tank = sp.GetService<IWeapon>();
  11.     tank.Fire();//飞机开火
  12. }

升级点的注入用法

同样的，只要我改变了创建依赖注入时 容器里的参数，凡是使用依赖注入的都跟着自动变。不用手动去改代码。多态的概念

  1. static void Main(string[] args)
  2. {
  3.     var sc = new ServiceCollection();
  4.     //两种方式都可以
  5.     sc.AddScoped(typeof(IWeapon), typeof(Fighter));
  6.     sc.AddScoped<IVehicle, Car>();
  8.     //传入一个类
  9.     //这个类实例化时需要传入一个IVehicle对象
  10.     //sc.AddScoped<Person>();
  11.     sc.AddScoped(typeof(Person));
  13.     var sp = sc.BuildServiceProvider();
  15.     //----------------------------------------
  17.     //调用时，不需要手动添加实现类，因为系统会自动在容器里面找IVehicle接口，找到了，发现实现类是Car
  18.     //所以给Person传入的就是Car对象，把Car注入进了Person
  19.     var p = sp.GetService<Person>();
  20.     p.Drive();//车在跑
  21. }

服务的生命周期

就是Add后面的半截方法名

Transient：每次被请求都会生成一个新的实例 Scoped：一次web请求产生一个实例，web请求被处理完生命周期就截止了 Singleton：这个服务的实例一旦被创建，以后用这个服务的时候都会只用这一个实例，会一直存活到这个项目停止运行