Pattern-engineering implementation and expansion

ArticleDirectory

• Books
• Positioning of books
• Key Points
• Sample features
• How to read

Books

This series is fully developed on the basis of "Design Patterns-engineering implementation and expansion based on C #". This series provides the following four books for C # developers and Java developers:

· Model-engineering implementation and expansion (Design Mode C)

· Mode-engineering implementation and expansion (Architecture Mode C)

· Mode-engineering implementation and expansion (design mode Java Edition)

· Mode-engineering implementation and expansion (Architecture mode Java Edition)

The Java version adopts the encoding style of Oracle JDK 6 and is intended for professionals on the Java SE & java ee 5/6 platform. The C # version adopts the encoding style and C #3/4. net Framework 3.5/4.0 built-in class libraries for professionals who use C.

The design pattern version only introduces the content of 23 gof design patterns. The example scenario is mainly oriented to the Type Design in process; the architecture mode section describes some typical architecture modes, data access modes, and Information Security modes from the perspective of distributed applications. Although the types are different, they are all required by the architecture, therefore, the architecture model is integrated into the sub-books. The example scenario also involves cross-process calls, and the distributed component technology is used.

Positioning of books

Whether you pick up the Java version, C # version, design mode version, or architecture mode version of this series,It is not a reader for beginners..

The content is arranged for middle and senior developers. The "self-check" section is designed for software architects who want to further challenge pattern technology.

Key Points

The focus of this series is not to elaborate on the design mode gof and the architecture mode itself 《Design Patterns: Elements of reusable object-oriented software. This series is intended for model practitioners. It assumes that you are familiar with Java or C # syntax, Can skillfully use Java 5/6 and C #3.0/4.0 syntax features, and fully explore the practical value, ensure that the work results are more concise and clear on the JVM and CLR & DLR platforms. This series also assumes that you have some knowledge about Java and C # compilers and byte code or msil, the delivery results can be evaluated from the byte code or msil layer.

Note: In the absence of other instructions, the design patterns referred to in this series refer to design patterns: Elements of reusable object-oriented software, which is translated into design patterns: this book can reuse the basics of object-oriented software.

For the modes that have been integrated into the language or development platform, for example: in gof, the prototype mode, command mode, policy mode, observer mode, iterator mode, visitor mode, and architecture mode include the MVC mode and pipeline filter.

Mode. We will try our best to use the language mechanism. You may not even see the obvious trace of the "Mode". The classic Implementation of the mode is only briefly introduced after the model intent. After all, the "Violent things" in the project is not worth advocating.

The design mode and architecture mode are a common solution to repeated problems under specific conditions. They are an idea and will also help design and implementation when used properly, from this perspective, it is actually productivity. From the beginning, this series of books are designed to implement each model in the simplest and closest way to the project. The implementation methods of the examples in the book are more oriented to the customers.ProgramIt is hoped that the customer program will be used more easily and conveniently. At the same time, it will evaluate the implementation methods of the book "design patterns" and analyze what needs to be adhered to and what should be abandoned.

Sample features

First, all examplesCodeThe implementation should be concise, but considering that the design mode should solve the "change" problem, the examples should be concise while taking appropriate care of the "strain" requirements. When writing code, unless you want to highlight an abstract interface, the code that can be written by one line is not written into multiple lines. This was mainly inspired by three non-software fields: Confucius's Spring and Autumn pen method, Einstein's energy equation, and the Moho diagram of the eight Mountain.

The "Spring and Autumn" compiled by Confucius can be described as "just a few simple words and meanings". A few pieces of content will reveal what we need to talk about now, however, such content has always affected our nation for more than 2000 years.

In the field of physics, Einstein's energy equations have been simplified to a degree that cannot be simplified. However, this formula's position and role in modern physics cannot be reviewed, the reason is that "physical things must be logically simple things". Redundant repeat will only make the methods and methods more clumsy.

Those in the eight mountains are also the leaders who stick to this concise style. We know that western painting requires various colors of oil color to reflect the texture and vividness of objects. However, only two colors of ink can vividly show the vitality of figures, animals, and plants in the painting, such as the lotus leaf in the F1-1, whether it is the context, color are vivid, and the lotus flower a few pen will reflect the color contrast and the feeling of anger.

Figure F1-1: Eight mountain people "mohetu" Vertical Axis

Recall that we did not try to write code like this.

A lot of code (comments are not counted) is a long article, but it is actually a duplicate of the Work of JDK,. NET Framework or other members of the team, and this lengthy code is often prone to errors.I believe that as long as someone participates in an IT system without errors, there is no such system in China, and there is no such system in the world. In the future, it will not be possible to say that in 100, and the lengthy code just increases the possibility of such errors..

Therefore, the coding of all examples in this series should be as simple, direct, and efficient as possible, whether it is Java code or C # code, whether it is design mode or architecture mode.

In addition, in the implementation mode of each mode, this series will always follow this priority encoding implementation for different extended themes:

· Java and C # syntax features

· Official Java se jdk and. NET Framework framework content

· Integration of officially supported open-source frameworks in some cases

· For open-source frameworks provided by other third parties, this series of implementation examples are not included or introduced.

Note:

In this article, "official" refers to Oracle and C # refer to Microsoft

Without other instructions, the. NET design specification referred to in this series refers to the design guidelines for developing class libraries.

How to read

In each chapter of this series of books, we will first briefly describe the classic introduction of the model, describe its main intent and typical implementation examples, and then gradually expand its use cases based on the language to introduce typical implementation skills.

For ease of use, we recommend that you read the books in this series as follows:

1. Understand the classic object-oriented design principles

2. Familiar with usageProgramming LanguageTo understand the differences between Engineering Code and toys code.

3. Then, read the introduction of the Classic Mode content in each chapter to understand why this mode is needed, what problems it mainly solves, and how it is implemented.

4. Read the extension section of each chapter to familiarize yourself with how to implement the expansion requirements in a more engineering way in different sample environments. To save space, the code in the book is just an excerpt from the code snippet. We recommend that you directly run the sample code to get a deeper understanding.

5. analyze and understand the unit test results.

6. Gradually combine your own project to modify the sample code, and truly integrate the "engineering implementation and expansion" in the book into your actual work.

In order to facilitate your understanding of the specific mode, this re-release adds a "self-testing" exercise in some chapters, with the aim of introducing some quasi-cases, it allows you to flexibly apply the knowledge content of this chapter and think about solutions independently. As the solution will be constantly adjusted and optimized, all the reference answers will be published in my personal blog, and the solution content will be constantly optimized and dynamically updated based on the results of communication with you. Hope you like this method. Below is my personal blog. You are welcome to visit it frequently:

Csdn http://blog.csdn.net/firevision/

Blog Park http://www.cnblogs.com/callwangxiang/

Iteye http://callwangxiang.iteye.com/

Finally, I wish you a better reading experience.