C#设计原则

学习设计原则是学习设计模式的基础。在实际的开发过程中,并不是一定要求所有的代码都遵循设计原则,而是要综合考虑人力、成本、时间、质量,不刻意追求完美,要在适当的场景遵循设计原则。

这体现的是一种平衡取舍,可以帮助我们设计出更加优雅的代码结构。

分别用一句话归纳总结软件设计七大原则,如下表所示:

设计原则一句话归纳目的
开闭原则对扩展开放,对修改关闭降低对维护带来的新风险
依赖倒置原则高层不应该依赖底层更利于代码结构的升级扩展
单一职责原则一个类只干一件事便于理解,提高代码的可读性
接口隔离原则一个接口只干一件事功能解耦,高聚合、低耦合
迪米特法则不该知道的不要知道只和朋友交流,不和陌生人说话,减少代码臃肿
里氏替换原则子类重写方式功能发生改变,不应该影响父类方法的含义防止继承泛滥
合成复用原则尽量使用组合实现代码复用,而不使用继承降低代码耦合

开闭原则示例

当使用C#编程语言时,可以通过以下示例来说明开闭原则的应用:

假设我们正在设计一个图形绘制应用程序,其中包含不同类型的图形(如圆形、矩形、三角形等)。

我们希望能够根据需要轻松地添加新的图形类型,同时保持现有代码的稳定性。

首先,我们定义一个抽象基类 Shape 来表示所有图形的通用属性和行为:

public abstract class Shape
{public abstract void Draw();
}

然后,我们创建具体的图形类,如 CircleRectangle 和 Triangle,它们都继承自 Shape 基类,并实现了 Draw() 方法:

public class Circle : Shape
{public override void Draw(){Console.WriteLine("Drawing a circle");}
}public class Rectangle : Shape
{public override void Draw(){Console.WriteLine("Drawing a rectangle");}
}public class Triangle : Shape
{public override void Draw(){Console.WriteLine("Drawing a triangle");}
}

现在,如果我们需要添加新的图形类型(例如椭圆),只需创建一个新的类并继承自 Shape 类即可。这样做不会影响现有代码,并且可以轻松地扩展应用程序。

public class Ellipse : Shape
{public override void Draw(){Console.WriteLine("Drawing an ellipse");}
}

在应用程序的其他部分,我们可以使用 Shape 类型的对象来绘制不同的图形,而无需关心具体的图形类型。这样,我们遵循了开闭原则,对扩展开放(通过添加新的图形类型),对修改关闭(不需要修改现有代码)。

public class DrawingProgram
{public void DrawShapes(List<Shape> shapes){foreach (var shape in shapes){shape.Draw();}}
}

使用示例:

var shapes = new List<Shape>
{new Circle(),new Rectangle(),new Triangle(),new Ellipse()
};var drawingProgram = new DrawingProgram();
drawingProgram.DrawShapes(shapes);

输出结果:

Drawing a circle
Drawing a rectangle
Drawing a triangle
Drawing an ellipse

通过遵循开闭原则,我们可以轻松地扩展应用程序并添加新的图形类型,而无需修改现有代码。这样可以提高代码的可维护性和可扩展性,并支持软件系统的演化和变化。

单一职责示例

单一职责原则(Single Responsibility Principle,SRP)要求一个类应该只有一个引起它变化的原因。换句话说,一个类应该只负责一项职责或功能。

下面是一个使用C#示例来说明单一职责原则的应用:

假设我们正在开发一个学生管理系统,其中包含学生信息的录入和展示功能。我们可以将这个系统分为两个类:Student 和 StudentManager

首先,定义 Student 类来表示学生对象,并包含与学生相关的属性和方法:

public class Student
{public string Name { get; set; }public int Age { get; set; }// 其他与学生相关的属性和方法...
}

然后,创建 StudentManager 类来处理与学生信息管理相关的操作,如录入、查询和展示等:

public class StudentManager
{private List<Student> students;public StudentManager(){students = new List<Student>();}public void AddStudent(Student student){// 将学生信息添加到列表中...students.Add(student);Console.WriteLine("Student added successfully.");}public void DisplayStudents(){// 展示所有学生信息...foreach (var student in students){Console.WriteLine($"Name: {student.Name}, Age: {student.Age}");}}
}

在这个例子中,Student 类负责表示单个学生对象,并封装了与学生相关的属性。而 StudentManager 类负责处理学生信息的管理操作,如添加学生和展示学生信息。

使用示例:

var student1 = new Student { Name = "Alice", Age = 20 };
var student2 = new Student { Name = "Bob", Age = 22 };var studentManager = new StudentManager();
studentManager.AddStudent(student1);
studentManager.AddStudent(student2);studentManager.DisplayStudents();

输出结果:

Student added successfully.
Student added successfully.
Name: Alice, Age: 20
Name: Bob, Age: 22

通过将学生对象的表示和管理操作分别封装在不同的类中,我们遵循了单一职责原则。Student 类只负责表示学生对象的属性,而 StudentManager 类只负责处理与学生信息管理相关的操作。这样可以提高代码的可维护性和可扩展性,并使每个类都具有清晰明确的职责。

里式替换

里氏替换原则(Liskov Substitution Principle,LSP)要求子类型必须能够替换其基类型,并且不会破坏程序的正确性。也就是说,子类可以在不影响程序正确性和预期行为的情况下替代父类。

下面是一个使用C#示例来说明里式替换原则的应用:

假设我们正在开发一个图形绘制应用程序,其中包含多种形状(如圆形、矩形等)。我们希望能够根据用户选择的形状类型进行绘制操作。

首先,定义一个抽象基类 Shape 来表示所有形状对象,并声明一个抽象方法 Draw 用于绘制该形状:

public abstract class Shape
{public abstract void Draw();
}

然后,创建具体的子类来表示不同的形状。例如,创建 Circle 类和 Rectangle 类分别表示圆形和矩形,并实现它们自己特定的绘制逻辑:

public class Circle : Shape
{public override void Draw(){Console.WriteLine("Drawing a circle...");}
}public class Rectangle : Shape
{public override void Draw(){Console.WriteLine("Drawing a rectangle...");}
}

在这个例子中,每个具体的子类都可以替代其基类 Shape 并实现自己特定的绘制逻辑。这符合里式替换原则,因为无论是 Circle 还是 Rectangle 都可以在不破坏程序正确性和预期行为的情况下替代 Shape

使用示例:

Shape circle = new Circle();
circle.Draw();  // 输出 "Drawing a circle..."Shape rectangle = new Rectangle();
rectangle.Draw();  // 输出 "Drawing a rectangle..."

通过将具体的子类对象赋值给基类引用变量,并调用相同的方法,我们可以看到不同形状的绘制操作被正确地执行。这证明了里式替换原则的有效性。

总结:里式替换原则要求子类型必须能够替代其基类型,并且不会破坏程序正确性。在C#中,我们可以通过创建具体的子类来表示不同形状,并确保它们能够在继承自抽象基类时正确地实现自己特定的行为。这样可以提高代码的可扩展性和灵活性,并使得代码更易于维护和重用。

依赖倒置

依赖倒置原则(Dependency Inversion Principle,DIP)要求高层模块不应该依赖于低层模块的具体实现,而是应该依赖于抽象。同时,抽象不应该依赖于具体实现细节,而是应该由高层模块定义。

下面是一个使用C#示例来说明依赖倒置原则的应用:

假设我们正在开发一个电子商务系统,其中包含订单处理和支付功能。我们希望能够根据用户选择的支付方式进行订单支付操作。

首先,定义一个抽象接口 IPaymentProcessor 来表示支付处理器,并声明一个方法 ProcessPayment 用于执行订单支付:

public interface IPaymentProcessor
{void ProcessPayment(decimal amount);
}

然后,在具体的实现类中分别实现不同的支付方式。例如,创建 CreditCardPaymentProcessor 类和 PayPalPaymentProcessor 类分别表示信用卡和PayPal支付,并实现它们自己特定的支付逻辑:

public class CreditCardPaymentProcessor : IPaymentProcessor
{public void ProcessPayment(decimal amount){Console.WriteLine($"Processing credit card payment of {amount} dollars...");// 具体信用卡支付逻辑...}
}public class PayPalPaymentProcessor : IPaymentProcessor
{public void ProcessPayment(decimal amount){Console.WriteLine($"Processing PayPal payment of {amount} dollars...");// 具体PayPal支付逻辑...}
}

在这个例子中,每个具体的支付处理器都实现了 IPaymentProcessor 接口,并提供了自己特定的支付逻辑。这样,高层模块(订单处理模块)就可以依赖于抽象接口 IPaymentProcessor 而不是具体的实现类。

使用示例:

public class OrderProcessor
{private IPaymentProcessor paymentProcessor;public OrderProcessor(IPaymentProcessor paymentProcessor){this.paymentProcessor = paymentProcessor;}public void ProcessOrder(decimal amount){// 处理订单逻辑...// 使用依赖注入的方式调用支付处理器paymentProcessor.ProcessPayment(amount);// 其他订单处理逻辑...}
}// 在应用程序中配置和使用不同的支付方式
var creditCardPayment = new CreditCardPaymentProcessor();
var payPalPayment = new PayPalPaymentProces 

接口隔离

接口隔离原则(Interface Segregation Principle,ISP)要求客户端不应该依赖于它们不使用的接口。一个类应该只依赖于它需要的接口,而不是依赖于多余的接口。

下面是一个使用C#示例来说明接口隔离原则的应用:

假设我们正在开发一个文件管理系统,其中包含文件上传和文件下载功能。我们希望能够根据用户需求提供相应的功能。

首先,定义两个接口 IFileUploadable 和 IFileDownloadable 来表示文件上传和文件下载功能,并分别声明相应的方法:

public interface IFileUploadable
{void UploadFile(string filePath);
}public interface IFileDownloadable
{void DownloadFile(string fileId);
}

然后,在具体的实现类中分别实现这两个功能。例如,创建 LocalFileManager 类来处理本地文件操作,并实现对应的方法:

public class LocalFileManager : IFileUploadable, IFileDownloadable
{public void UploadFile(string filePath){Console.WriteLine($"Uploading file from local path: {filePath}");// 具体本地上传逻辑...}public void DownloadFile(string fileId){Console.WriteLine($"Downloading file with ID: {fileId} to local path");// 具体本地下载逻辑...}
}

在这个例子中,每个具体的实现类只关注自己需要用到的接口方法,而不需要实现多余的方法。这符合接口隔离原则,因为客户端可以根据需要依赖于相应的接口。

使用示例:

public class FileManagerClient
{private IFileUploadable fileUploader;private IFileDownloadable fileDownloader;public FileManagerClient(IFileUploadable fileUploader, IFileDownloadable fileDownloader){this.fileUploader = fileUploader;this.fileDownloader = fileDownloader;}public void UploadAndDownloadFiles(string filePath, string fileId){// 使用文件上传功能fileUploader.UploadFile(filePath);// 使用文件下载功能fileDownloader.DownloadFile(fileId);// 其他操作...}
}// 在应用程序中配置和使用具体的文件管理类
var localFileManager = new LocalFileManager();
var client = new FileManagerClient(localFileManager, localFileManager);
client.UploadAndDownloadFiles("path/to/file", "123456");

通过依赖注入的方式,我们可以将具体的实现类传递给客户端,并根据需要调用相应的接口方法。这样就遵循了接口隔离原则,使得客户端只依赖于它们所需的接口,并且不会受到多余方法的影响。这提高了代码的可维护性和灵活性,并促进了代码重用和扩展。

迪米特

迪米特法则(Law of Demeter,LoD),也称为最少知识原则(Principle of Least Knowledge),要求一个对象应该对其他对象有尽可能少的了解。一个类不应该直接与其他类耦合,而是通过中间类进行通信。

下面是一个使用C#示例来说明迪米特法则的应用:

假设我们正在开发一个社交网络系统,其中包含用户、好友和消息等功能。我们希望能够实现用户发送消息给好友的功能。

首先,定义三个类 UserFriend 和 Message 来表示用户、好友和消息,并在 User 类中实现发送消息的方法:

public class User
{private string name;private List<Friend> friends;public User(string name){this.name = name;this.friends = new List<Friend>();}public void AddFriend(Friend friend){friends.Add(friend);}public void SendMessageToFriends(string messageContent){Message message = new Message(messageContent);foreach (Friend friend in friends){friend.ReceiveMessage(message);}Console.WriteLine($"User {name} sent a message to all friends.");}
}public class Friend
{private string name;public Friend(string name){this.name = name;}public void ReceiveMessage(Message message){Console.WriteLine($"Friend {name} received a message: {message.Content}");// 处理接收到的消息...}
}public class Message
{public string Content { get; set; }public Message(string content){Content = content;}
}

在这个例子中,User 类表示用户,Friend 类表示好友,Message 类表示消息。用户可以添加好友,并通过 SendMessageToFriends 方法向所有好友发送消息。

使用示例:

User user1 = new User("Alice");
User user2 = new User("Bob");Friend friend1 = new Friend("Charlie");
Friend friend2 = new Friend("David");user1.AddFriend(friend1);
user2.AddFriend(friend2);user1.SendMessageToFriends("Hello, friends!");

在这个示例中,用户对象只与好友对象进行通信,并不直接与消息对象进行通信。这符合迪米特法则的要求,即一个对象应该尽可能少地了解其他对象。

通过将消息发送的责任委托给好友对象,在用户类中只需要调用 friend.ReceiveMessage(message) 方法来发送消息给所有好友。这样可以降低类之间的耦合性,并提高代码的可维护性和灵活性。

合成复用

合成复用原则(Composite Reuse Principle,CRP)要求尽量使用对象组合,而不是继承来达到复用的目的。通过将现有对象组合起来创建新的对象,可以更灵活地实现功能的复用和扩展。

下面是一个使用C#示例来说明合成复用原则的应用:

假设我们正在开发一个图形库,其中包含各种形状(如圆形、矩形等)。我们希望能够实现一个可以绘制多个形状的画板。

首先,定义一个抽象基类 Shape 来表示图形,并声明抽象方法 Draw

public abstract class Shape
{public abstract void Draw();
}

然后,在具体的子类中分别实现各种形状。例如,创建 Circle 类和 Rectangle 类来表示圆形和矩形,并重写父类中的 Draw 方法:

public class Circle : Shape
{public override void Draw(){Console.WriteLine("Drawing a circle");// 具体绘制圆形逻辑...}
}public class Rectangle : Shape
{public override void Draw(){Console.WriteLine("Drawing a rectangle");// 具体绘制矩形逻辑...}
}

接下来,创建一个画板类 Canvas 来管理并绘制多个图形。在该类中使用对象组合将多个图形组合在一起:

public class Canvas
{private List<Shape> shapes;public Canvas(){shapes = new List<Shape>();}public void AddShape(Shape shape){shapes.Add(shape);}public void DrawShapes(){foreach (Shape shape in shapes){shape.Draw();}Console.WriteLine("All shapes are drawn.");}
}

在这个例子中,Canvas 类通过对象组合的方式将多个图形对象组合在一起,并提供了添加图形和绘制图形的方法。

使用示例:

Canvas canvas = new Canvas();Circle circle = new Circle();
Rectangle rectangle = new Rectangle();canvas.AddShape(circle);
canvas.AddShape(rectangle);canvas.DrawShapes();

在这个示例中,我们创建了一个画板对象 canvas,并向其中添加了一个圆形和一个矩形。然后调用 DrawShapes 方法来绘制所有的图形。

通过使用对象组合而不是继承,我们可以更灵活地实现功能的复用和扩展。例如,可以轻松地添加新的图形类型或修改现有图形类型的行为,而不会影响到画板类。这符合合成复用原则,并提高了代码的可维护性和灵活性。

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

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

相关文章

SRE运维揭秘: 企业生产中运维监控的真相

大家好&#xff0c;我是博哥爱运维&#xff0c;有着十年SRE运维开发经验&#xff0c;从事过全球多个主流云平台的服务架构设计及自动化运维开发工作&#xff0c;在企业中基于gitlab和k8s从零设计过完整的一套CICD流水线架构&#xff0c;曾用shell开发过运维堡垒机系统&#xff…

磁盘未格式化,数据恢复有妙招

一、初遇磁盘未格式化&#xff0c;惊慌失措 在日常生活和工作中&#xff0c;我们经常会使用各种存储设备来保存重要的文件和数据。然而&#xff0c;有时当我们尝试访问这些存储设备时&#xff0c;却会突然遇到一个令人头痛的问题——磁盘未格式化。这个突如其来的提示让我们措…

虚拟函数和普通函数的区别?内联函数和构造函数能否成为虚拟函数?

虚拟函数和普通函数的区别主要在于它们的调用方式。当一个类中有虚拟函数时&#xff0c;编译器会为该类创建一个虚函数表&#xff08;vtable&#xff09;&#xff0c;这个表中存储了该类中所有虚拟函数的地址。在运行时&#xff0c;通过基类的指针或引用调用派生类中的函数时&a…

[Python初阶]2255.统计是给定字符串前缀的字符串数目

目录 2255.统计是给定字符串前缀的字符串数目 ①.题目 ②.问题分析 ③.startswith()方法理解 与 说明 Ⅰ.定义和用法 Ⅱ.语法 ④.问题解决 ⑤总结 2255.统计是给定字符串前缀的字符串数目 ①.题目 ②.问题分析 需求:统计列表words中,是字符串s的前缀的字符串的数目. 解…

【解惑】离线版本的软件如何实现“授权验证”和“使用有效期”验证的

如何实现 要实现软件授权验证和使用有效期验证的离线版本&#xff0c;可以考虑以下几个步骤&#xff1a; 授权验证&#xff1a; 在软件的离线版本中&#xff0c;可以通过在软件中嵌入一个授权验证模块来进行验证。授权验证模块可以包含一个加密算法&#xff0c;用于生成和验证…

接口与多态

通过接口实现多态 接口中声明若干个 bstract方法&#xff1b; 方法体的内容细节由实现接口的类去完成&#xff0c;不同的类有 不同的实现方式 → 则接口变量在回调接口方法时具有多 种形态。 用接口进行程序设计的核心思想 使用接口回调技术&#xff1a;接口变量存放实现该接口…

(学习日记)2024.03.13:UCOSIII第十五节:基于时基列表的时延操作(持续更新)

写在前面&#xff1a; 由于时间的不足与学习的碎片化&#xff0c;写博客变得有些奢侈。 但是对于记录学习&#xff08;忘了以后能快速复习&#xff09;的渴望一天天变得强烈。 既然如此 不如以天为单位&#xff0c;以时间为顺序&#xff0c;仅仅将博客当做一个知识学习的目录&a…

Redis集群原理解析

一、单机Redis存在的问题 问题1&#xff1a;数据丢失问 解决方案&#xff1a;利用RDB和AOF实现数据的持久化 问题2&#xff1a;并发能力弱 解决方案&#xff1a;搭建主从集群&#xff0c;实现主从分离 问题3&#xff1a;存储空间小 解决方案&#xff1a;搭建分片集群&#xff0…

KY191 矩阵幂(用Java实现)

描述 给定一个n*n的矩阵&#xff0c;求该矩阵的k次幂&#xff0c;即P^k。 输入描述&#xff1a; 第一行&#xff1a;两个整数n&#xff08;2<n<10&#xff09;、k&#xff08;1<k<5&#xff09;&#xff0c;两个数字之间用一个空格隔开&#xff0c;含义如上所示…

《LeetCode热题100》笔记题解思路技巧优化_Part_3

《LeetCode热题100》笔记&题解&思路&技巧&优化_Part_3 &#x1f60d;&#x1f60d;&#x1f60d; 相知&#x1f64c;&#x1f64c;&#x1f64c; 相识&#x1f622;&#x1f622;&#x1f622; 开始刷题链表&#x1f7e2;1. 相交链表&#x1f7e2;2. 反转链表&…

大数据数据分析-scala、IDEA、jdk之间的搭配关系

Scala主要是一门面向对象编程语言和函数式编程语言。 一、大数据框架&#xff08;处理海量/流式数据&#xff09; - ---以HADOOP 2. x为系列的大数据生态系统处理框架 离线数据分析&#xff0c;分析的数据为N1天数据 -----MapReduce 并行计算框架&#xff0c;分而治之…

数据治理系统论-结合数据要素等

什么是数据治理&#xff1f; 数据治理是指组织内外部对数据进行管理和监控的全面框架。它涵盖了数据的安全、合规性、可用性和价值最大化等方面。通过有效的数据治理&#xff0c;组织能够更好地理解其数据资产&#xff0c;并确保数据被正确地管理和利用。 数据治理的重要性 在…

django实现api接口

&#xff08;前期准备&#xff09;第一步&#xff1a;虚拟环境 在windows上使用virtualenvwrapper。 pip install virtualenvwrapper-win 接着&#xff0c;添加环境变量。 echo %WORKON_HOME% 接下来就是创建虚拟环境&#xff0c;假如创建myenv mkvirtualenv myenv 进入…

sqllab第二十八关通关笔记(附带28a)

知识点&#xff1a; union select 整体过滤 union all select 替换where id(输入)空格 过滤了&#xff0c;使用%09代替 经过不断的测试&#xff0c;发现原始语句为 where id(输入) 构造payload:id1)and%091(1 成功回显出了相关的信息 好&#xff0c;尝试进行错误注入 构造…

acwing 3302. 表达式求值

​​​​​​给定一个表达式&#xff0c;其中运算符仅包含 ,-,*,/&#xff08;加 减 乘 整除&#xff09;&#xff0c;可能包含括号&#xff0c;请你求出表达式的最终值。 注意&#xff1a; 数据保证给定的表达式合法。题目保证符号 - 只作为减号出现&#xff0c;不会作为负号…

java虚拟机的堆核心知识介绍

Java虚拟机&#xff08;JVM&#xff09;的堆&#xff08;Heap&#xff09;是Java内存模型中一个至关重要的部分。它是运行时数据区&#xff0c;用于存储Java对象实例。堆是垃圾收集器工作的地方&#xff0c;也是Java应用程序内存管理的关键区域。在本教程中&#xff0c;我们将深…

nvm安装,nvm使用及常用命令,node版本管理

前端学习交流QQ群&#xff1a;1群&#xff1a;173683895 &#xff0c;2群: 173683866 承接项目开发&#xff0c;需求功能开发&#xff0c;博主微信号&#xff1a;Jay_09168 安装包下载地址 下载使用 安装&#xff1a; 点击 nvm-setup.exe&#xff0c;按下图步骤安装&#…

STM32系列——F103C8T6 控制SG90舵机(HAL库)

文章目录 一、舵机控制原理二、.CubeMX配置配置RCC、SYS、时钟树配置RCC配置SYS配置时钟树配置定时器产生PWM波形 Keil5代码接线图及效果如果您发现文章有错误请与我留言&#xff0c;感谢 一、舵机控制原理 舵机的控制一般需要一个20ms左右的时基脉冲&#xff0c;该脉冲的高电平…

(含链接)2024年NVIDIA GPU技术大会开发者合集(专为开发者挑选的合集)

2024年NVIDIA GPU技术大会开发者合集 我专门为开发者整理了NVIDIA GPU技术大会上专注技术的内容合集, 希望可以帮助开发者朋友们快速了解NVIDIA的最新技术. 注意:在电脑端打开更友好, 可以直接进入每一项的网页 文章目录 2024年NVIDIA GPU技术大会开发者合集如何登录和预约会…

[AutoSar]BSW_Com015 PDUR 模块配置

目录 关键词平台说明一、Abbreviations二、PduRBswModules三、PduRGeneration四、PduRDestPdus4.1 全局PDU ID和本地PDU ID 关键词 嵌入式、C语言、autosar、OS、BSW 平台说明 项目ValueOSautosar OSautosar厂商vector &#xff0c; EB芯片厂商TI 英飞凌编程语言C&#xff0…