必知必会的设计原则——依赖倒置原则

概述

开放封闭原则是面向对象的设计的中级目标，而依赖倒置原则是实现开放封闭原则的基础。
如果开放封闭原则是设计大楼的蓝田，那么依赖倒置原则就是大楼的钢铁架构。
高层模块（调用者）不应该依赖于低层模块（被调用者），两个都应该依赖于抽象。依赖倒置原则的本质是通过接口或抽象使各个模块的实现独立，彼此互补影响，从而实现模块间的松耦合。
未使用依赖倒置原则的代码

1.     /// <summary>
2.     /// 重复代码很多， Singer作为高层模块，严重依赖底层模块 不符合依赖倒置原则，开放封闭原则 -单一职责原则
3.     /// </summary>
4.     public class Singer
5.     {
6.         public void SingSong(ChineseSong chineseSong)
7.         {
8.             Console.WriteLine($"歌手正在唱{chineseSong.GetSongWords()}");
9.         }
10.         public void SingSongEnglish(EnglishSong englishSong)
11.         {
12.             Console.WriteLine($"歌手正在唱{englishSong.GetSongWords()}");
13.         }
14.     }
16.     public class ChineseSong
17.     {
18.     public string GetSongWords()
19.         {
20.             return "中国歌曲";
21.         }
22.     }
23.     public class EnglishSong
24.     {
25.         public string GetSongWords()
26.         {
27.             return "外国歌曲";
28.         }
29.     }

复制代码

1. //C#控制台调用
2. Singer singer = new Singer();
3. singer.SingSong(new ChineseSong());
4. singer.SingSongEnglish(new EnglishSong());

复制代码

结论：重复代码很多， Singer作为高层模块，严重依赖底层模块 不符合依赖倒置原则，开放封闭原则 -单一职责原则。
面向接口编程的代码

1. public interface ISongWords
2.     {
3.         public string GetSongWords();
4.     }
6.     public class ChineseSong2: ISongWords
7.     {
8.         public string GetSongWords()
9.         {
10.             return "中国歌曲";
11.         }
12.     }
13.     public class EnglishSong2 : ISongWords
14.     {
15.         public string GetSongWords()
16.         {
17.             return "外国歌曲";
18.         }
19.     }
21.     public class Singer2
22.     {
23.         public void SingSong(ISongWords songWords)
24.         {
25.             Console.WriteLine($"歌手正在唱{songWords.GetSongWords()}");
26.         }
27.     }

复制代码

1. //C#控制台调用
2. Singer2 singer2 = new Singer2();
3. ISongWords songWords = new ChineseSong2();
4. singer2.SingSong(songWords);

复制代码

依赖倒置原则的代码

抽象不应该依赖细节  细节应该依赖抽象。

1.     public interface ICar
2.     {
3.         void Run();
4.     }
5.     public class Benz : ICar
6.     {
7.         public void Run()
8.         {
9.             Console.WriteLine("奔驰汽车在本跑");
10.         }
11.     }
12.     public class AoDi : ICar
13.     {
14.         public void Run()
15.         {
16.             Console.WriteLine("奥迪汽车在本跑");
17.         }
18.     }
21.     public interface IDriver
22.     {
23.         //在接口或类中 将要注入的服务对象，以参数的形式直接注入，我们称之为接口注入；
24.         void Drive(ICar car);
25.         void Drive();
26.         void SetCar(ICar car);
27.     }
28.     public class Student : IDriver
29.     {
30.         private ICar _car;
31.        /// <summary>
32.        /// 接口注入
33.        /// </summary>
34.        /// <param name="car"></param>
35.         public void Drive(ICar car)
36.         {
37.           car.Run();
38.         }
40.         public void Drive()
41.         {
42.             _car.Run();
43.         }
44.         /// <summary>
45.         /// 属性注入
46.         /// </summary>
47.         /// <param name="car"></param>
48.         public void SetCar(ICar car)
49.         {
50.             _car=car;   
51.         }
52.     }
53.     public class Teacher : IDriver
54.     {
55.         private readonly ICar _car;
56.         /// <summary>
57.         /// 构造函数注入
58.         /// </summary>
59.         /// <param name="car"></param>
60.         public Teacher(ICar car)
61.         {
62.             _car = car;
63.         }
64.         public void Drive(ICar car)
65.         {
66.             throw new NotImplementedException();
67.         }
68.         public void SetCar(ICar car)
69.         {
70.             throw new NotImplementedException();
71.         }
72.         public void Drive()
73.         {
74.             _car.Run();
75.         }
76.     }

复制代码

1. //C#控制台调用
2. IDriver driver = new Student();
3. ICar car = new Benz();
4. driver.Drive(car);
6. driver.SetCar(car);
7. driver.Drive();
9. IDriver driver1 = new Teacher(car);
10. driver1.Drive(car);

复制代码

总结

以上就是关于依赖倒置原则的内容，有何疑问，欢迎与我沟通交流。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

继续阅读请点击广告