查看: 774|回复: 0

[ASP.NET教程] 浅谈IOC

发表于 2017-7-9 13:24:17

一、引言

IOC-Invertion of Control,即控制反转,是一种程序设计思想,世上本没有路,走的人多了便有了路,本文将一步步带你了解IOC设计思想的演进之路。

在学习IOC之前我们先初步了解几个概念

依赖(Dependency):就是有联系,表示一个类依赖于另一个类

依赖倒置原则(DIP):设计模式六大原则之一,是一种软件架构设计原则

控制反转(IOC):一种软件设计原则,上层对下层的依赖(即底层模块的获得)交给第三方

依赖注入(DI):实现IOC的一种方式、手段

IOC容器:依赖注入的框架,用来映射依赖,管理对象创建和生存周期

二、依赖

依赖就是有联系,有地方使用它就是有依赖它,下面看一个简单的示例

  1. class BMW
  2. {
  3. public string Show()
  4. {
  5. return "宝马";
  6. }
  7. }
  8. class ChinesePeople
  9. {
  10. private BMW bmw = new BMW();
  11. public void Run()
  12. {
  13. Console.WriteLine($"今天开{bmw.Show()}上班");
  14. }
  15. }
  16. class Program
  17. {
  18. static void Main(string[] args)
  19. {
  20. ChinesePeople people = new ChinesePeople();
  21. BMW bmw = new BMW();
  22. people.Run();
  23. Console.Read();
  24. }
  25. }
复制代码
View Code

上面中国人开着宝马去上班,客户端有使用中国人、宝马汽车两个对象,中国人中有使用对象宝马汽车,我们可以从中找到三个依赖关系:

客户端依赖对象ChinesePeople;

客户端依赖对象BMW;

ChinesePeople依赖对象BMW;

三、依赖倒置原则

过些日子来了新需求,中国人不仅要开宝马去上班,还要开奔驰去上班,如果按照上面直接依赖关系的方式去做,我们就需要修改ChinesePeople类,让它实现一个参数为宝马的重载方法Run(),显然这样不是好的设计,我们总不能每次新增一种汽车(即修改下层模块)都要去修改ChinesePeople类吧(相对于汽车为上层模块),太麻烦了。。。

先简单分析一下,耦合关系就是依赖关系,如果依赖关系很重,牵一发而动全身,将很难维护扩展,耦合关系越少,系统会越稳定,因此要较少依赖

定义:A.高层模块不应依赖于底层模块,两者应该依赖于抽象

   B.抽象不应该依赖于细节,细节应该依赖于抽象

在这个图中,我们发现高层模块定义接口,将不直接依赖于下层模块,下层模块负责实现高层模块定义的接口,下面看代码demo:

  1. interface ICar
  2. {
  3. string Show();
  4. }
  5. class BMW:ICar
  6. {
  7. public string Show()
  8. {
  9. return "宝马";
  10. }
  11. }
  12. class BenZ : ICar
  13. {
  14. public string Show()
  15. {
  16. return "奔驰";
  17. }
  18. }
  19. interface IPeople
  20. {
  21. void Run(ICar bmw);
  22. }
  23. class ChinesePeople :IPeople
  24. {
  25. public void Run(ICar bmw)
  26. {
  27. Console.WriteLine($"今天开{bmw.Show()}上班");
  28. }
  29. }
  30. class Program
  31. {
  32. static void Main(string[] args)
  33. {
  34. ICar carBMW = new BMW();
  35. ICar carBenZ = new BenZ();
  36. IPeople people = new ChinesePeople();
  37. people.Run(carBMW);
  38. people.Run(carBenZ);
  39. Console.Read();
  40. }
  41. }
复制代码
View Code

分析:上面代码中,ChinesePeople类不再依赖于具体的汽车,而是依赖于汽车的抽象,这样使得不管换什么样的汽车品牌,中国人都是可以开着去上班的,而且不需要修改ChinesePeople类。想一下,这样是不是挺好的,我们可以得出:上层不再依赖细节,相比面向实现,面向接口较好,因为抽象相比细节要更稳定。

四、控制反转

上面示例中,我们实现了具体的人和具体的汽车的隔离,具体人只和汽车的接口有关。但是Program中main方法里的具体对象写死了,控制权变小,当我要修改美国人开着福特去上班时,就不得不要去修改代码,那怎么把控制权转移呢?

下面看一个简单的示例:

  1. interface ICar
  2. {
  3. string Show();
  4. }
  5. class BMW:ICar
  6. {
  7. public string Show()
  8. {
  9. return "宝马";
  10. }
  11. }
  12. interface IPeople
  13. {
  14. void Run(ICar bmw);
  15. }
  16. class ChinesePeople :IPeople
  17. {
  18. public void Run(ICar bmw)
  19. {
  20. Console.WriteLine($"今天开{bmw.Show()}上班");
  21. }
  22. }
  23. class Program
  24. {
  25. static void Main(string[] args)
  26. {
  27. string people = ConfigurationManager.AppSettings["people"];
  28. string car = ConfigurationManager.AppSettings["car"];
  29. Assembly assemblypeople = Assembly.Load(people.Split(',')[1]);
  30. Assembly assemblycar = Assembly.Load(car.Split(',')[1]);
  31. Type typepeople = assemblypeople.GetType(people.Split(',')[0]);
  32. Type typecar = assemblypeople.GetType(car.Split(',')[0]);
  33. IPeople ipeople= (IPeople)Activator.CreateInstance(typepeople);
  34. ICar icar = (ICar)Activator.CreateInstance(typecar);
  35. ipeople.Run(icar);
  36. Console.Read();
  37. }
  38. }
  39. <?xml version="1.0" encoding="utf-8" ?>
  40. <configuration>
  41. <startup>
  42. <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
  43. </startup>
  44. <appSettings>
  45. <add key="people" value="MyIOC_IOC.ChinesePeople,MyIOC_IOC"/>
  46. <add key="car" value="MyIOC_IOC.BMW,MyIOC_IOC"/>
  47. </appSettings>
  48. </configuration>
复制代码
View Code

上面代码中,我们使用反射+配置文件的方式,将对象创建的控制权转移到了配置文件,这就是所谓的控制反转

分析,控制反转是将对象创建的控制权交给了第三方,可以是IOC容器,它就相当于工厂,我们要什么对象,工厂给我们什么对象,这样依赖关系就变了,它们(人和车)都依赖于IOC容器,通过IOC容器建立它们之间的依赖关系。(依赖对象不再被依赖模块的类中直接通过new来获取)

五、依赖注入

上面说到的控制反转,我们了解到是将控制权转移,这是我们的目的,配置文件+反射是是一种实现,而依赖注入则提供的是一种思想,或者说是实现IOC的手段。

依赖注入是将对象的创建和绑定转移到被依赖对象的外部来实现。在依赖关系中ChinesePeople类所依赖的对象BMW类的创建和绑定是在ChinesePeople类内部执行的,显然这种方法是不可取的,那我们怎么BMW类的引用传递给ChinesePeople类呢?

方法一 构造函数注入

  1. interface ICar
  2. {
  3. string Show();
  4. }
  5. class BMW:ICar
  6. {
  7. public string Show()
  8. {
  9. return "宝马";
  10. }
  11. }
  12. class ChinesePeopleContructor
  13. {
  14. private ICar _car;
  15. public ChinesePeopleContructor(ICar bmw)
  16. {
  17. _car = bmw;
  18. }
  19. public void Run()
  20. {
  21. Console.WriteLine($"今天开{_car.Show()}上班");
  22. }
  23. }
  24. static void Main(string[] args)
  25. {
  26. ICar car = new BMW();
  27. ChinesePeopleContructor people = new ChinesePeopleContructor(car);
  28. people.Run();
  29. Console.Read();
  30. }
复制代码
View Code

分析,BMW类对象的创建和绑定转移到ChinesePeople类的外部来实现,解除了两个对象之间的耦合,当需要开奔驰去上班的时候,只需要定义一个奔驰类,外部重新绑定依赖,不需要修改ChinesePeople类的内部,即可是先中国人开奔驰去上班的需求

方法二 属性注入

  1. interface ICar
  2. {
  3. string Show();
  4. }
  5. class BMW:ICar
  6. {
  7. public string Show()
  8. {
  9. return "宝马";
  10. }
  11. }
  12. class ChinesePeopleProperty
  13. {
  14. private ICar _ICar;
  15. public ICar IC
  16. {
  17. get { return _ICar; }
  18. set { _ICar = value; }
  19. }
  20. public void Run()
  21. {
  22. Console.WriteLine($"今天开{_ICar.Show()}上班");
  23. }
  24. }
  25. static void Main(string[] args)
  26. {
  27. ICar car = new BMW();
  28. ChinesePeopleProperty people = new ChinesePeopleProperty();
  29. people.IC = car;
  30. people.Run();
  31. Console.Read();
  32. }
复制代码
View Code

分析,属性注入是通过给属性赋值,从而传递依赖

方法三 接口注入

  1. interface ICar
  2. {
  3. string Show();
  4. }
  5. class BMW:ICar
  6. {
  7. public string Show()
  8. {
  9. return "宝马";
  10. }
  11. }
  12. interface IDependent
  13. {
  14. void SetDependent(ICar icar);
  15. }
  16. class ChinesePeopleInterface : IDependent
  17. {
  18. private ICar _ICar;
  19. public void SetDependent(ICar icar)
  20. {
  21. _ICar = icar;
  22. }
  23. public void Run()
  24. {
  25. Console.WriteLine($"今天开{_ICar.Show()}上班");
  26. }
  27. }
  28. static void Main(string[] args)
  29. {
  30. ICar car = new BMW();
  31. ChinesePeopleInterface people = new ChinesePeopleInterface();
  32. people.SetDependent(car);
  33. people.Run();
  34. Console.Read();
  35. }
复制代码
View Code

分析,接口依赖是定义一个设置依赖的方法,然后被依赖类继承并实现这个接口

六、IOC容器

IOC容器是一个DI框架,主要功能有一下几点

1.动态创建、注入依赖对象;

2.管理对象生命周期

2.映射依赖关系

常见的IOC容器:Spring.NET,Castle Windsor, Ninject,Autofac,Unity等等。。。

ioc容器提供了很多丰富的API,由于时间和篇幅等关系,我会在下篇博客中和您一起学习IOC容器之一Unity,敬请期待,未完待续。。。

不努力一把,坐井观天,将永远不知道自己和别人的差距有多大,身为菜鸟的我相信,天道酬勤,大道至简,最好的成功之道便是坚持、学习、总结。

本文版权归作者和博客园共有,欢迎转载,转载请注明出处。感谢您的阅读。



回复

使用道具 举报