Shulou(Shulou.com)06/03 Report--

This article introduces the knowledge of "single responsibility principle in c # design pattern". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Single principle: when programming, the functional module is independent, and the single function is more conducive to maintenance and reuse.

For example, personal computers have so many functions that it is difficult to come up with only one function to create a new thing. At the same time, if your computer doesn't work, and your calculator function doesn't work.

In programming, if a class encapsulates too much functionality, the result is similar to the above.

Principle of single responsibility

Example 1:

You should be able to see that there is something wrong with the interface design in this class diagram, and there is no separation between the user's properties and the user's behavior. We disassemble this interface based on the user's properties and behavior.

Re-split into two interfaces, IUserBo is responsible for the user's attributes, and IUserBiz is responsible for the user's behavior. When we instantiate the object except UserINfo, we can use UserInfo as an IUserBo implementation class or as an IUserBiz implementation class, depending on where we use it. If you are getting user information, think of UserInfo as the implementation class of IUserBOSS, and if you are maintaining user information, it is regarded as the implementation class of IUserBiz. In practical applications, we prefer to split an interface into two, one is IUserBO and the other is IUserBIz. The class diagram is as follows.

After doing this, we split an interface into two, which is in line with the principle of single responsibility, so what is the principle of single responsibility?

The core idea of the principle of single responsibility is: a class, it is best to do only one thing, and there is only one reason for its change.

The principle of single responsibility can be regarded as an extension of the object-oriented principle of low coupling and high cohesion. Responsibility is defined as the cause of change in order to improve cohesion to reduce the cause of change. If there are too many responsibilities, there are more reasons that may cause changes, which will lead to responsibility dependence and influence each other, thus greatly damaging its cohesion and coupling. A single responsibility usually means a single function, so don't implement too many function points for the class to ensure that the entity has only one reason for its change. Example 2:

Rectangle has two methods, one is draw, which is used to draw graphics, and the other is that area is used to calculate the area. Rectangle violates the principle of single responsibility because it has two responsibilities: calculating the area and drawing the rectangle. Drawing graphics is related to the user interface, but calculating the graphic area is not necessarily related to the interface. If you write these two responsibilities into a class, then if you only need to use the area () method to calculate the area, you will have to compile the draw () method together, but you may not need it. If one of the responsibilities needs to be modified, the other has to be recompiled and deployed. If the class has more than one responsibility, there will be coupling between those responsibilities. Changing one responsibility may affect and hinder the function of the class to serve other classes. It would be better to separate the two duties.

The two duties are separated, so the degree of coupling will be reduced. The core of the SRP principle is that there can be only one change to the class. Classes that violate this principle should be refactored, such as separating responsibilities by Fa ç ade mode or Proxy mode, and combing through the basic methods of Extract Interface, Extract Class and Extract Method.

Example 3: take a look at the following interface

Public interface Phone {/ / dial public void dial (string phoneNumber); / / call public void chat (object o); / / respond to public void answer (object o); / / call over public void huangup ();}

Is there something wrong with this interface? There's a problem. A single responsibility requires that an interface or class changes for only one reason, that is, an interface or class has only one responsibility, and it is responsible for one thing. The Phone interface is not a responsibility, it has two responsibilities: one is protocol management, the other is data transmission. The two methods diag () and huangup () implement protocol management, dialing and hanging up. Chat () and answer () are data transfers. Both protocol changes and data transfer can cause class changes, so we cannot say that it is in line with the principle of single responsibility. Since the changes in the two responsibilities do not affect each other, consider splitting them into two interfaces.

This class diagram already conforms to the principle of single responsibility, but it is much more complex. The combination is a strong coupling relationship, and both of them have a common lifetime. This strong coupling increases the complexity of the class. Let's modify it.

This is the perfect design. A mobile phone implements two interfaces and merges two responsibilities into one class. Although you will think that this phone class has two reasons for change, we are interface-oriented programming and publish interfaces, not implementation classes. If you want to make the class conform to the principle of single responsibility, then use the previous class diagram, but then the coupling of the class will be increased.

Benefits of the single responsibility principle: reduced class complexity, improved readability, improved maintainability, reduced risk caused by change

This is the end of the content of "single responsibility principle in c # Design pattern". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.