solid design principles c#

The so-called No recruit wins a recruit, practice a kung fu divides into internal strength and drilling.Drilling is like the moves, is the so-called 23 kinds of design patterns. But the internal strength, is the heart, that is the 6 kinds of laws. Light will drilling that is huaquanxiutui, the internal strength is the situation.So many design patterns, learned 2 times. 3 times you'll probably forget just th

Labels: Object-oriented Design Principles After the previous in-depth explanation, we have basically made it clear about the solid principle. However, if you want to skillfully apply the solid principle, it is not enough to know what the solid is, we also need to know when a

principles.d) "Conflict" in the principles of inheritance and combinatorial aggregation multiplexingInheritance can also be reused, is that the principle of abandoning inheritance? No.Inheritance pays more attention to "descent", which is what type. Combinatorial aggregation is more focused on borrowing "skills". Also, in combinatorial aggregation, two classes are part-to-whole relationships, and combinatorial aggregation can consist of multiple clas

I. Design Pattern principles: 1,Single responsibility principle: Specific description: there should be only one reason for a class change, that is, a method should do only one thing as much as possible, that is, to implement only one function as much as possible, and an interface should be responsible for only one class of function description as much as possible, the

right, here's a bunch of crap. The six principles of object-oriented design are now formally introducedI. Opening and closing principle (OCP)Defined:open for extensions, close for modifications. For example: Your class has monitor, study Committee, sports committee and so on a series of class cadres. Because in a collective activity your organization ability is the teacher fancy, want to promote you on dut

Pattern--seven kinds:Adapter mode, adorner mode, proxy mode, appearance mode, bridge mode, combined mode, enjoy meta mode;③ Behavior Pattern--11 kinds:Strategy mode, template method mode, observer mode, iterative sub-mode, responsibility chain mode, Command mode, Memo mode, state mode, visitor mode, intermediary mode, interpreter mode;4, MVC design mode--Combination design mode:①m--model--model data; v--vi

1. Opening and closing principle (the Open Closed principle OCP) A module should be open in terms of extensibility and should be closed in terms of modification. Therefore, the interface encapsulation mechanism, abstract mechanism and polymorphic technique should be considered as far as possible in object-oriented design. The principle is also suitable for non object-oriented design method, is one of the i

Object-oriented design principles are the core of programming for Oops (object-oriented programming System, Object-oriented program design systems), but most Java programmers Chase Singleton, Decorator, Observer such a design pattern, rather than focusing on object-oriented analysis and

); } } classChengextendsjisuan{//sub-class multiplication Public functionJs () {//computed functions for subclasses overridesParent::Js (); return($this->a*$this-C); } } classChuextendsjisuan{//sub-class division Public functionJs () {//computed functions for subclasses overridesParent::Js (); return($this->a/$this-b); } } classQuyuextendsjisuan{//sub-class take -up Public functionJs () {//computed

coupling. ----- The concrete coupling relationship. The two classes are dependent on each other, This is the specific coupling relationship. If a specific class directly references another specific class This relationship is generated. ----- Abstract coupling relationship, which occurs in a specific class and a smoke In this way, the maximum flexibility is maintained between classes that must have a relationship. Why is dependency inversion?The dependency between object-oriented prog

The object-oriented design principle is the core of OOPS (object-oriented programming system, Object-Oriented Programming System) programming. However, most Java programmers pursue design patterns such as Singleton, decorator, and observer, instead of focusing on Object-Oriented Analysis and Design. Even experienced Java programmers have never heard of OOPS and

Tags: efficiency file Cap File System Runtime design principles Description Program implementation recommendations1. Relationship between the original document and the entityCan be a pair of one or one-to-many, many-to-many relationships. In general, they are one-to-one relationships: a single original document corresponds to and corresponds to only an entity.In special cases, they may be one-to-many or man

The object-oriented design principle is the core of OOPS (object-oriented programming system) programming.Design patterns such as Singleton, decorator, and observer do not focus on Object-Oriented Analysis and Design. There are even experiencedJava programmers have never heard of OOPS and solid design

million), the complex calculation is first outside the database, the file system sideAfter the processing of the C + + language is completed, the final storage is appended to the table. This is the experience of telecom billing system design.(3) If a table is found to have too many records, such as more than 10 million, the table is split horizontally. The horizontal split is done with the table primary ke

Object-Oriented design principles:Is the core of programming for Oops (object-oriented programming System, Object-oriented program design systems), but most Java programmers chase design patterns like Singleton, Decorator, and Observer, Rather than focusing on object-oriented analysis and design. Even experienced Java

interface I relies on Class D, and if interface I is not the smallest interface for Class A and Class B, then Class B and Class D must implement methods that they do not need, such as:Modify: Split the bloated interface I into separate interfaces, and Class A and Class C are dependent on the interfaces they need. That is, the principle of interface isolation. Note:1), the interface as small as possible, but there must be a limit. The refinement of th

the final implementation of the object-oriented design pattern is still expressed in the object-oriented programming language, which is based on the C # language, but in fact it is suitable for support. NET Framework for all. NET languages, such as Visual Basic.NET, C + +/CLI, and so on. Object-oriented design pattern