C#实践设计模式原则SOLID

理论跟实践的关系,说远不远,说近不近。能不能把理论用到实践上,还真不好说。

通常讲到设计模式,一个最通用的原则是SOLID:

  1. S - Single Responsibility Principle,单一责任原则

  2. O - Open Closed Principle,开闭原则

  3. L - Liskov Substitution Principle,里氏替换原则

  4. I - Interface Segregation Principle,接口隔离原则

  5. D - Dependency Inversion Principle,依赖倒置原则

嗯,这就是五大原则。

后来又加入了一个:Law of Demeter,迪米特法则。于是,就变成了六大原则。

原则好理解。怎么用在实践中?

一、单一责任原则

单一责任原则,简单来说就是一个类或一个模块,只负责一种或一类职责。

看代码:

public interface IUser
{void AddUser();void RemoveUser();void UpdateUser();void Logger();void Message();
}

根据原则,我们会发现,对于IUser来说,前三个方法:AddUserRemoveUserUpdateUser是有意义的,而后两个LoggerMessage作为IUser的一部分功能,是没有意义的并不符合单一责任原则的。

所以,我们可以把它分解成不同的接口:

public interface IUser
{void AddUser();void RemoveUser();void UpdateUser();
}
public interface ILog
{void Logger();
}
public interface IMessage
{void Message();
}

拆分后,我们看到,三个接口各自完成自己的责任,可读性和可维护性都很好。

下面是使用的例子,采用依赖注入来做:

public class Log : ILog
{public void Logger(){Console.WriteLine("Logged Error");}
}
public class Msg : IMessage
{public void Message(){Console.WriteLine("Messaged Sent");}
}
class Class_DI
{private readonly IUser _user;private readonly ILog _log;private readonly IMessage _msg;public Class_DI(IUser user, ILog log, IMessage msg){this._user = user;this._log = log;this._msg = msg;}public void User(){this._user.AddUser();this._user.RemoveUser();this._user.UpdateUser();}public void Log(){this._log.Logger();}public void Msg(){this._msg.Message();}
}
public static void Main()
{Class_DI di = new Class_DI(new User(), new Log(), new Msg());di.User();di.Log();di.Msg();
}

这样的代码,看着就漂亮多了。

二、开闭原则

开闭原则要求类、模块、函数等实体应该对扩展开放,对修改关闭。

我们先来看一段代码,计算员工的奖金:

public class Employee
{public int Employee_ID;public string Name;public Employee(int id, string name){this.Employee_ID = id;this.Name = name;}public decimal Bonus(decimal salary){return salary * .2M;}
}
class Program
{static void Main(string[] args){Employee emp = new Employee(101, "WangPlus");Console.WriteLine("Employee ID: {0} Name: {1} Bonus: {2}", emp.Employee_ID, emp.Name, emp.Bonus(10000));}
}

现在假设,计算奖金的公式做了改动。

要实现这个,我们可能需要对代码进行修改:

public class Employee
{public int Employee_ID;public string Name;public string Employee_Type;public Employee(int id, string name, string type){this.Employee_ID = id;this.Name = name;this.Employee_Type = type;}public decimal Bonus(decimal salary){if (Employee_Type == "manager")return salary * .2M;elsereturnsalary * .1M;}
}

显然,为了实现改动,我们修改了类和方法。

这违背了开闭原则。

那我们该怎么做?

我们可以用抽象类来实现 - 当然,实际有很多实现方式,选择最习惯或自然的方式就成:

public abstract class Employee
{public int Employee_ID;public string Name;public Employee(int id, string name){this.Employee_ID = id;this.Name = name;}public abstract decimal Bonus(decimal salary);
}

然后,我们再实现最初的功能:

public class GeneralEmployee : Employee
{public GeneralEmployee(int id, string name) : base(id, name){}public override decimal Bonus(decimal salary){return salary * .2M;}
}
class Program
{public static void Main(){Employee emp = new GeneralEmployee(101, "WangPlus");Console.WriteLine("Employee ID: {0} Name: {1} Bonus: {2}", emp.Employee_ID, emp.Name, emp.Bonus(10000));}
}

在这儿使用抽象类的好处是:如果未来需要修改奖金规则,则不需要像前边例子一样,修改整个类和方法,因为现在的扩展是开放的。

代码写完整了是这样:

public abstract class Employee
{public int Employee_ID;public string Name;public Employee(int id, string name){this.Employee_ID = id;this.Name = name;}public abstract decimal Bonus(decimal salary);
}public class GeneralEmployee : Employee
{public GeneralEmployee(int id, string name) : base(id, name){}public override decimal Bonus(decimal salary){return salary * .1M;}
}
public class ManagerEmployee : Employee
{public ManagerEmployee(int id, string name) : base(id, name){}public override decimal Bonus(decimal salary){return salary * .2M;}
}
class Program
{public static void Main(){Employee emp = new GeneralEmployee(101, "WangPlus");Employee emp1 = new ManagerEmployee(102, "WangPlus1");Console.WriteLine("Employee ID: {0} Name: {1} Bonus: {2}", emp.Employee_ID, emp.Name, emp.Bonus(10000));Console.WriteLine("Employee ID: {0} Name: {1} Bonus: {2}", emp1.Employee_ID, emp1.Name, emp1.Bonus(10000));}
}

三、里氏替换原则

里氏替换原则,讲的是:子类可以扩展父类的功能,但不能改变基类原有的功能。它有四层含义:

  1. 子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法;

  2. 子类中可以增加自己的特有方法;

  3. 当子类重载父类的方法时,方法的前置条件(形参)要比父类的输入参数更宽松;

  4. 当子类实现父类的抽象方法时,方法的后置条件(返回值)要比父类更严格。

在前边开闭原则中,我们的例子里,实际上也遵循了部分里氏替换原则,我们用GeneralEmployeeManagerEmployee替换了父类Employee

还是拿代码来说。

假设需求又改了,这回加了一个临时工,是没有奖金的。

public class TempEmployee : Employee
{public TempEmployee(int id, string name) : base(id, name){}public override decimal Bonus(decimal salary){throw new NotImplementedException();}
}
class Program
{public static void Main(){Employee emp = new GeneralEmployee(101, "WangPlus");Employee emp1 = new ManagerEmployee(101, "WangPlus1");Employee emp2 = new TempEmployee(102, "WangPlus2");Console.WriteLine("Employee ID: {0} Name: {1} Bonus: {2}", emp.Employee_ID, emp.Name, emp.Bonus(10000));Console.WriteLine("Employee ID: {0} Name: {1} Bonus: {2}", emp1.Employee_ID, emp1.Name, emp1.Bonus(10000));Console.WriteLine("Employee ID: {0} Name: {1} Bonus: {2}", emp2.Employee_ID, emp2.Name, emp2.Bonus(10000));Console.ReadLine();}
}

显然,这个方式不符合里氏替原则的第四条,它抛出了一个错误。

所以,我们需要继续修改代码,并增加两个接口:

interface IBonus
{decimal Bonus(decimal salary);
}
interface IEmployee
{int Employee_ID { get; set; }string Name { get; set; }decimal GetSalary();
}
public abstract class Employee : IEmployee, IBonus
{public int Employee_ID { get; set; }public string Name { get; set; }public Employee(int id, string name){this.Employee_ID = id;this.Name = name;}public abstract decimal GetSalary();public abstract decimal Bonus(decimal salary);
}
public class GeneralEmployee : Employee
{public GeneralEmployee(int id, string name) : base(id, name){}public override decimal GetSalary(){return 10000;}public override decimal Bonus(decimal salary){return salary * .1M;}
}
public class ManagerEmployee : Employee
{public ManagerEmployee(int id, string name) : base(id, name){}public override decimal GetSalary(){return 10000;}public override decimal Bonus(decimal salary){return salary * .1M;}
}
public class TempEmployee : IEmployee
{public int Employee_ID { get; set; }public string Name { get; set; }public TempEmployee(int id, string name){this.Employee_ID = id;this.Name = name;}public decimal GetSalary(){return 5000;}
}
class Program
{public static void Main(){Employee emp = new GeneralEmployee(101, "WangPlus");Employee emp1 = new ManagerEmployee(102, "WangPlus1");Console.WriteLine("Employee ID: {0} Name: {1} Salary: {2} Bonus:{3}", emp.Employee_ID, emp.Name, emp.GetSalary(), emp.Bonus(emp.GetSalary()));Console.WriteLine("Employee ID: {0} Name: {1} Salary: {2} Bonus:{3}", emp1.Employee_ID, emp1.Name, emp1.GetSalary(), emp1.Bonus(emp1.GetSalary()));List<IEmployee> emp_list = new List<IEmployee>();emp_list.Add(new GeneralEmployee(101, "WangPlus"));emp_list.Add(new ManagerEmployee(102, "WangPlus1"));emp_list.Add(new TempEmployee(103, "WangPlus2"));foreach (var obj in emp_list){Console.WriteLine("Employee ID: {0} Name: {1} Salary: {2} ", obj.EmpId, obj.Name, obj.GetSalary());}}
}

四、接口隔离原则

接口隔离原则要求客户不依赖于它不使用的接口和方法;一个类对另一个类的依赖应该建立在最小的接口上。

通常的做法,是把一个臃肿的接口拆分成多个更小的接口,以保证客户只需要知道与它相关的方法。

这个部分不做代码演示了,可以去看看上边单一责任原则里的代码,也遵循了这个原则。

五、依赖倒置原则

依赖倒置原则要求高层模块不能依赖于低层模块,而是两者都依赖于抽象。另外,抽象不应该依赖于细节,而细节应该依赖于抽象。

看代码:

public class Message
{public void SendMessage(){Console.WriteLine("Message Sent");}
}
public class Notification
{private Message _msg;public Notification(){_msg = new Message();}public void PromotionalNotification(){_msg.SendMessage();}
}
class Program
{public static void Main(){Notification notify = new Notification();notify.PromotionalNotification();}
}

这个代码中,通知完全依赖Message类,而Message类只能发送一种通知。如果我们需要引入别的类型,例如邮件和SMS,则需要修改Message类。

下面,我们使用依赖倒置原则来完成这段代码:

public interface IMessage
{void SendMessage();
}
public class Email : IMessage
{public void SendMessage(){Console.WriteLine("Send Email");}
}
public class SMS : IMessage
{public void SendMessage(){Console.WriteLine("Send Sms");}
}
public class Notification
{private IMessage _msg;public Notification(IMessage msg){this._msg = msg;}public void Notify(){_msg.SendMessage();}
}
class Program
{public static void Main(){Email email = new Email();Notification notify = new Notification(email);notify.Notify();SMS sms = new SMS();notify = new Notification(sms);notify.Notify();}
}

通过这种方式,我们把代码之间的耦合降到了最小。

六、迪米特法则

迪米特法则也叫最少知道法则。从称呼就可以知道,意思是:一个对象应该对其它对象有最少的了解。

在写代码的时候,尽可能少暴露自己的接口或方法。写类的时候,能不public就不public,所有暴露的属性、接口、方法,都是不得不暴露的,这样能确保其它类对这个类有最小的了解。

这个原则没什么需要多讲的,调用者只需要知道被调用者公开的方法就好了,至于它内部是怎么实现的或是有其他别的方法,调用者并不关心,调用者只关心它需要用的。反而,如果被调用者暴露太多不需要暴露的属性或方法,那么就可能导致调用者滥用其中的方法,或是引起一些其他不必要的麻烦。

最后说两句:所谓原则,不是规则,不是硬性的规定。在代码中,能灵活应用就好,不需要非拘泥于形式,但是,用好了,会让代码写得很顺手,很漂亮。

(全文完)

喜欢就来个三连,让更多人因你而受益

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/308182.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

81. 搜索旋转排序数组 II(014)二分查找+思路+详解+二种做法

一&#xff1a;题目 已知存在一个按非降序排列的整数数组 nums &#xff0c;数组中的值不必互不相同。 在传递给函数之前&#xff0c;nums 在预先未知的某个下标 k&#xff08;0 < k < nums.length&#xff09;上进行了 旋转 &#xff0c;使数组变为 [nums[k], nums[k1…

学校考的计算机三级证书,全国计算机等级考试证书用途

全国计算机等级考试证书用途计算机知识浩如瀚海&#xff0c;即使任何资深人士都不可能精通或熟悉所有的计算机软件&#xff0c;但是为什么他们无论什么软件都能很快就上手会用呢&#xff0c;那是因为本质上任何计算机软件都是C语言之类的编程语言开发出来的&#xff0c;所以我们…

10-4 6-4 查询厂商“D“生产的PC和便携式电脑的平均价格 (10 分)思路+详解+测试用例

前言&#xff1a;测试用表 贴心杰将这个测试表分享给大家 &#xff0c;如果大家做题的时候发现那个点过不去&#xff0c;一定不要直接看别人的博客&#xff0c;先自己测试用例&#xff0c;如果思路也对 &#xff0c;验证数据也对&#xff0c;还有错误 你再看看别人的思路&…

如何校验内存数据的一致性,DynamicExpresso 算是帮上大忙了

一&#xff1a;背景1. 讲故事记的在上一家公司做全内存项目的时候&#xff0c;因为一些关键表会在程序 startup 的时候全量灌入到内存中&#xff0c;但随着时间的推移&#xff0c;内存和数据库的同步偶尔会出现数据差异的情况&#xff0c;伴随着就是运营那边报过来的 bug&#…

qt 实现html 编辑器,基于QT的HTML编辑器的设计与实现.doc

PAGEPAGE 1郑州大学毕业设计(论文)题 目&#xff1a;基于Qt的html编辑器的设计与实现指导教师&#xff1a; 职称&#xff1a;学生姓名&#xff1a; 学号&#xff1a;专 业&#xff1a;院(系)&#xff1a;完成时间&#xff1a; 2012年5月10日2012年5月10日目录TOC \o "1-2&…

临界表储存图的数据(思路+详解+图示)

一&#xff1a;前言 当我们考虑用邻接表储存数据的时候&#xff0c;一定会拿邻接矩阵和其进行比较。邻接矩阵在储存数量较小的数据是耗费的内存是要高于邻接表的。那么我们在做题的时候如果出现内存超限&#xff0c;那就要注意了&#xff0c;可以考虑换用邻接表来储存数据了 …

译 | 在 Azure SQL 上节约成本的八种方法

点击上方关注“汪宇杰博客”原文&#xff1a;John JG Chirapurath翻译&#xff1a;汪宇杰导语当今世界&#xff0c;企业正崭露头角&#xff0c;渴望重整与重建&#xff0c;但仍处于不确定的时期。节约成本并将开支重新分配到最重要的位置与以往一样重要&#xff0c;许多公司将云…

7-2 单源最短路径 (10 分)(思路+详解+邻接表做法)Come Brather!!!!!!!!!!

一&#xff1a;前言 本次题解先展示用邻接矩阵做的&#xff0c;但其会出现内存超限&#xff0c;因为确实是临界矩阵在数据很大的时候相比临界表是耗内存的&#xff0c;但是以前习惯用临界矩阵了&#xff0c;所以一上来就用临界矩阵做了&#xff0c;后来上网查了后知道邻接矩阵…

计算机一级办公软件试题,计算机一级《MS Office》练习题(含答案)

计算机一级《MS Office》练习题(含答案)11.完整的计算机软件指的是__________.A.程序、数据与相应的文档B.系统软件与应用软件C.操作系统与应用软件D.操作系统和办公软件12.在微机的配置中常看到“P42.4G”字样,其中数字“2.4G”表示__________.A.处理器的时钟频率是2.4GHzB.处…

在.NET Core中使用MongoDB明细教程(3):Skip, Sort, Limit, Projections

到目前为止&#xff0c;我们已经讨论了创建文档, 检索文档&#xff0c;现在让我们来研究一下文档排序&#xff0c;指定要跳过或限制返回的文档数量&#xff0c;以及如何进行投影。此篇文章中的实例代码摘录自原文&#xff0c;未像前几篇文章一样进行实际代码的验证。作者&#…

map容器的使用 逆序遍历map容器当中的数据

一&#xff1a;前言 这个逆序遍历是将map容器的迭代器进行了变化&#xff0c;reverse_iterator逆向遍历的迭代器 &#xff0c;它需要 rbegin()和rend()方法指出反向遍历的 起始位置和终止位置。 二&#xff1a;上码演示 #include<bits/stdc.h> using namespace std;in…

计算机检测维修与数据恢复课件,2017年全国职业院校技能大赛中职组“计算机检测维修与数据恢复”赛项说明会ppt课件.ppt...

《2017年全国职业院校技能大赛中职组“计算机检测维修与数据恢复”赛项说明会ppt课件.ppt》由会员分享&#xff0c;可在线阅读&#xff0c;更多相关《2017年全国职业院校技能大赛中职组“计算机检测维修与数据恢复”赛项说明会ppt课件.ppt(23页珍藏版)》请在人人文库网上搜索。…

递归优化的这三种方式你知道吗?

估计找工作的&#xff0c;都会碰到面试官老是问道“递归算法”&#xff0c;感同身受&#xff0c;前段时间面试的时候&#xff0c;就有一家问道这个问题&#xff0c;是非常典型的问题。在前面一篇世界上有哪些代码量很少&#xff0c;但很牛逼很经典的算法或项目案例&#xff1f;…

7-7 硬币找钱问题 (10 分)(思路+详解+double类型数据的处理)Come baby!!!!!!!!!!!!!!!!!!!!

一&#xff1a;题目 设有6 种不同面值的硬币&#xff0c;各硬币的面值分别为5 分&#xff0c;1 角&#xff0c;2 角&#xff0c;5 角&#xff0c;1 元&#xff0c;2元。现要用这些面值的硬币来购物。在购物中希望使用最少个数硬币。例如&#xff0c;1 次购物需要付款0.55 元&a…

7-6 区间覆盖 (10 分)(思路+详解)Come 宝!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

一&#xff1a;题目 设 x 1 ​ ,x 2 ​ ,…,x n ​ 是实直线上的n个点。用固定长度的闭区间覆盖这n个点&#xff0c;至少需要多少个这样的固定长度闭区间&#xff1f; 输入格式: 第1行有2个正整数n(n<50)和k&#xff0c;表示有n个点&#xff0c;且固定长度闭区间的长度为k…

你有 GitHub 帐号么?平时都用它来干什么?

这是头哥侃码的第212篇原创上个月&#xff0c;我写了一篇 #与抑郁症斗争的那些年&#xff0c;我也曾想去死一死#&#xff0c;分享了自己在创业失败那段时间的抑郁焦虑的经历。很显然&#xff0c;这已经不是我第一次把自己的悲惨经历写出来了。在文章推送后&#xff0c;有读者在…

xml可以html标签吗,自定义html标签(XML)

HTML和HTML5都可以自定义标签。在浏览一些网站的源代码后&#xff0c;你会发现一些网页中存在你不认识的标签和元素&#xff0c;但是这些元素却能被浏览器执行。这就是自定义元素。自由定义标签而不必使用预定义好的语义标签之后&#xff0c;更能语义化我们的内容。在HTML5之前…

7-5 汽车加油问题 (20 分)(思路+详解)Come 宝!!!!!!!!!!!!!

一&#xff1a;题目 题目来源&#xff1a;王晓东《算法设计与分析》 一辆汽车加满油后可行驶 n公里。旅途中有若干个加油站。设计一个有效算法&#xff0c;指出应 在哪些加油站停靠加油&#xff0c;使沿途加油次数最少。 输入格式: 第一行有 2 个正整数n和 k&#xff08;k&l…

在生产环境下处理EFCore数据库迁移的五种方法

在生产环境下处理EFCore数据库迁移的五种方法原文链接&#xff1a;https://www.thereformedprogrammer.net/handling-entity-framework-core-database-migrations-in-production-part-1/作者:Jon P Smith&#xff0c;是《 Entity Framework Core in Action》的作者安德鲁洛克&a…

计算机系统结构答案汤志忠,计算机系统结构(第2版)郑伟明汤志忠课后习题答案以及例题收录.doc...

计算机系统结构(第2版)郑伟明汤志忠课后习题答案以及例题收录.doc 1计算机系统结构第2版郑伟明汤志忠编著清华大学出版社习题解答21目录11第一章P331719(透明性概念)&#xff0c;112118(AMDAHL定律)&#xff0c;119、121、124(CPI/MIPS)12第二章P12423、25、26(浮点数性能)&…