翼度科技»论坛 编程开发 .net 查看内容

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

5

主题

5

帖子

15

积分

新手上路

Rank: 1

积分
15
概述

开放封闭原则是面向对象的设计的中级目标,而依赖倒置原则是实现开放封闭原则的基础。
如果开放封闭原则是设计大楼的蓝田,那么依赖倒置原则就是大楼的钢铁架构。
高层模块(调用者)不应该依赖于低层模块(被调用者),两个都应该依赖于抽象。依赖倒置原则的本质是通过接口或抽象使各个模块的实现独立,彼此互补影响,从而实现模块间的松耦合。
未使用依赖倒置原则的代码
  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.     }
  15.     public class ChineseSong
  16.     {
  17.     public string GetSongWords()
  18.         {
  19.             return "中国歌曲";
  20.         }
  21.     }
  22.     public class EnglishSong
  23.     {
  24.         public string GetSongWords()
  25.         {
  26.             return "外国歌曲";
  27.         }
  28.     }
复制代码
  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.     }
  5.     public class ChineseSong2: ISongWords
  6.     {
  7.         public string GetSongWords()
  8.         {
  9.             return "中国歌曲";
  10.         }
  11.     }
  12.     public class EnglishSong2 : ISongWords
  13.     {
  14.         public string GetSongWords()
  15.         {
  16.             return "外国歌曲";
  17.         }
  18.     }
  19.     public class Singer2
  20.     {
  21.         public void SingSong(ISongWords songWords)
  22.         {
  23.             Console.WriteLine($"歌手正在唱{songWords.GetSongWords()}");
  24.         }
  25.     }
复制代码
  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.     }
  19.     public interface IDriver
  20.     {
  21.         //在接口或类中 将要注入的服务对象,以参数的形式直接注入,我们称之为接口注入;
  22.         void Drive(ICar car);
  23.         void Drive();
  24.         void SetCar(ICar car);
  25.     }
  26.     public class Student : IDriver
  27.     {
  28.         private ICar _car;
  29.        /// <summary>
  30.        /// 接口注入
  31.        /// </summary>
  32.        /// <param name="car"></param>
  33.         public void Drive(ICar car)
  34.         {
  35.           car.Run();
  36.         }
  37.         public void Drive()
  38.         {
  39.             _car.Run();
  40.         }
  41.         /// <summary>
  42.         /// 属性注入
  43.         /// </summary>
  44.         /// <param name="car"></param>
  45.         public void SetCar(ICar car)
  46.         {
  47.             _car=car;   
  48.         }
  49.     }
  50.     public class Teacher : IDriver
  51.     {
  52.         private readonly ICar _car;
  53.         /// <summary>
  54.         /// 构造函数注入
  55.         /// </summary>
  56.         /// <param name="car"></param>
  57.         public Teacher(ICar car)
  58.         {
  59.             _car = car;
  60.         }
  61.         public void Drive(ICar car)
  62.         {
  63.             throw new NotImplementedException();
  64.         }
  65.         public void SetCar(ICar car)
  66.         {
  67.             throw new NotImplementedException();
  68.         }
  69.         public void Drive()
  70.         {
  71.             _car.Run();
  72.         }
  73.     }
复制代码
  1. //C#控制台调用
  2. IDriver driver = new Student();
  3. ICar car = new Benz();
  4. driver.Drive(car);
  5. driver.SetCar(car);
  6. driver.Drive();
  7. IDriver driver1 = new Teacher(car);
  8. driver1.Drive(car);
复制代码
总结

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

来源:https://www.cnblogs.com/mhg215/archive/2023/02/08/17097888.html
免责声明:由于采集信息均来自互联网,如果侵犯了您的权益,请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容,谢谢合作!

举报 回复 使用道具