构建灵活代码：C#中的适应性设计模式与SOLID原则

5星 · 超过95%的资源需积分: 9 123 浏览量更新于2024-07-22 收藏 34.47MB PDF 举报

"Adaptive Code via C# (MS,2014)" 是一本由 Gary McLean Hall 编写的书籍，专注于敏捷编程和如何通过 C# 语言构建适应性代码。书中强调了设计模式、SOLID 原则在应对需求变化时的重要性，帮助开发者创建灵活、可适应的代码，从而提高业务价值。本书内容覆盖了以下几个关键知识点： 1. **敏捷编程与Scrum基础**：介绍Scrum框架的基本要素，包括工件（如产品待办事项列表、迭代待办事项列表）、角色（如产品负责人、开发团队、Scrum主管）、度量标准以及不同阶段的工作流程。 2. **架构依赖的组织与管理**：讲解如何规划和管理软件架构中的依赖关系，确保系统的模块化和可扩展性。 3. **设计模式与反模式**：探讨最佳的设计模式实践，同时避免反模式，以提高代码的可读性和可维护性。 4. **SOLID原则**：深入理解并应用单一职责原则、开闭原则、里氏替换原则，这些原则有助于编写易于维护和扩展的代码。 5. **接口的灵活性**：探讨如何利用接口来提升代码的适应性，使代码更容易调整和复用。 6. **单元测试与重构**：介绍如何将单元测试和重构结合起来，以确保代码质量并逐步改进代码结构。 7. **委托与抽象**：解释委托和抽象如何影响代码的适应性，以及如何有效地使用它们来增强系统的灵活性。 8. **依赖注入**：讨论最佳的依赖注入实现方式，以减少耦合，提高代码的可测试性和可维护性。 9. **实战项目**：通过一个实际的敏捷编码项目，应用所学知识，让读者能够在实践中巩固理论。这本书是微软出版社出版，适合有一定 C# 开发经验的程序员阅读，旨在帮助他们将理论知识转化为实际开发中的有效实践，以应对不断变化的软件需求。书中内容严谨，实例丰富，旨在缩小理论与实践之间的差距，提升开发者的专业技能。

ptg14200592

Introduction

he rst words of the title of this book, Adaptive Code, provide a good description

of the outcome of applying the principles in the book: the ability of code to adapt

to any new requirement or unforeseen scenario while avoiding signicant rework. The

aim of this book is to aggregate into one volume many of the current best practices in

the world of C# programming with the Microsoft .NET Framework. Although some of

the content is covered in other books, those books either focus heavily on theory or are

not specic to .NET development.

Programming can be a slow process. If your code is adaptive, you will be able to

make changes to it more quickly, more easily, and with fewer errors than you would

if you were working with a codebase that impedes changes. Requirements, as every

developer knows, are subject to change. How change is managed is a key differen-

tiating factor between successful software projects and those that atrophy due to scope

creep. Developers can react in many ways to requirement changes, with two opposing

viewpoints highlighting the continuum that lies between.

First, developers can choose a rigid viewpoint. In this approach, from the develop-

ment process down to class design, the project is as inexible as if it were implemented

50 years ago by using punch cards. Waterfall methodologies are conspicuous culprits

in ensuring that software cannot change freely. Their determination that the phases of

analysis, design, implementation, and testing be distinct and one-way make it difcult—

or at least expensive—for customers to change requirements after implementation has

begun. The code, then, does not need to be built for change: the process all but forbids

alterations.

The second approach, Agile methodology, is not just an alternative to such rigid

methodologies, but a reaction to them. The aim of Agile processes is to embrace change

as a necessary part of the contract between client and developer. If customers want to

change something in the product that they are paying for, the temporal and nancial

cost should be correlated to the size of the change, not the phase of the process that is

currently in progress. Unlike physical engineering, software engineering works with a

malleable tool: source code. The bricks and mortar that form a house are literally fused

together as construction progresses. The expense involved in changing the design of

a house is necessarily linked to the completion of the building phase. If the project

has not been started—if it is still just in blueprints—change is relatively cheap. If the

windows are in, the electricity wired up, and the plumbing tted, moving the upstairs

bathroom down next to the kitchen could be prohibitively expensive. With code, mov-

ing features around and reworking the navigation of a user interface should not be as

From the Library of Ida Schander

www.it-ebooks.info

ptg14200592

xvi Introduction

signicant. Unfortunately, this is not always the case. The temporal cost alone often

prohibits such changes. This, I nd, is largely a result of a lack of adaptability in code.

This book demonstrates the second approach and explains, with real-world exam-

ples, the practicalities of implementing adaptive code.

Who should read this book

This book is intended to bridge a gap between theory and practice. The reader for

whom this book is written is an experienced programmer who seeks more practical

examples of design patterns, SOLID principles, unit testing and refactoring, and more.

Capable intermediate programmers who want to plug the gaps in their knowledge

or have doubts and questions about how some of the industry’s best practices t

together will benet most from this book, especially because the day-to-day reality

of programming rarely matches simple examples or theory. Much of SOLID is now

understood, but the intricacies of the open/closed principle (covered in Chapter 6)

and Liskov substitution (covered in Chapter 7) are not fully comprehended. Even

experienced programmers sometimes do not fully realize the benets provided by

dependency injection (covered in Chapter 9). Similarly, the exibility—adaptability—

that interfaces (covered in Chapter 3) lend to code is often overlooked.

This book can also help the more junior developer learn, from the ground up, which

aspects of common patterns and practices are benevolent and which are, in the long

term, malevolent. The code samples that I see from prospective employees have a lot

in common. The general theme is that the candidate is almost there with respect to

many skills but just needs a slight push in the right direction to become a signicantly

better programmer. Specically, the Entourage anti-pattern (covered in Chapter 2) and

the Service Locator anti-pattern (covered in Chapter 9) are very prevalent in sample

code. Practical alternatives, and their rationales, are provided in this book.

Assumptions

Ideally, you should have some practical experience of programming in a language that

is syntactically similar to C#, such as Java or C++. You should also have a strong founda-

tion in core procedural programming concepts such as conditional branching, loops,

and expressions. You should also have some experience of object-oriented program-

ming using classes, and at least a passing familiarity with interfaces.

From the Library of Ida Schander

www.it-ebooks.info

ptg14200592

Introduction xvii

This book might not be for you if…

This book might not be for you if you are just starting out on a journey to learn how to

program. This book covers advanced topics that assume a thorough understanding of

fundamental programming concepts.

Organization of this book

This book is made up of three parts, each of which builds on the last. That said, the

book can also be read out of order. Each chapter covers a self-contained subject in

detail, with cross references included where appropriate.

Part I: An Agile foundation

This part lays the foundation for building software in an adaptive way. It covers the

high-level Agile process known as Scrum, which requires code to be adaptive to change.

The chapters in this part focus on details around interfaces, design patterns, refactoring,

and unit testing.

■

Chapter 1: Introduction to Scrum This chapter sets the scene for the book

by introducing Scrum, which is an Agile project management methodology. The

chapter gives an in-depth overview of the artifacts, roles, metrics, and phases

of a Scrum project. Finally, it shows how developers should organize themselves

and their code when operating in an Agile environment.

■

Chapter 2: Dependencies and layering This chapter explores dependencies

and architectural layering. Code can only be adaptive if the solution’s structure

allows it to be. The different types of dependencies are described: rst-party,

third-party, and framework. The chapter describes how to manage and organize

dependencies, from anti-patterns (which should be avoided) to patterns (which

should be embraced). It also introduces advanced topics such as aspect-oriented

programming and asymmetric layering, providing further depth.

■

Chapter 3: Interfaces and design patterns Interfaces are, by now, ubiquitous

in modern .NET development. However, they are often misapplied, misunder-

stood, and misappropriated. This chapter shows some of the more common and

practically useful design patterns, exploring how versatile an interface can be.

Leading the reader beyond the simple extraction of an interface, the chapter

From the Library of Ida Schander

www.it-ebooks.info

ptg14200592

xviii Introduction

shows how interfaces can be elaborated in many different ways to solve a

problem. Mixins, duck-typing, and interface uency further underscore the

versatility of this key weapon in the programmer’s arsenal.

■

Chapter 4: Unit testing and refactoring Two practices that are becoming

prerequisite skills are unit testing and refactoring. The two are closely related

and work in unison to produce adaptive code. Without the safety net of unit

tests, refactoring is prone to error; without refactoring, code becomes unwieldy,

rigid, and hard to comprehend. This chapter takes an example of unit testing

from humble beginnings and expands it to use more advanced—but practical

—patterns and practices such as uent assertions, test-driven development,

and mocking. For refactoring, the chapter provides examples of real-world

refactors that improve the readability and maintainability of the source code.

Part II: Writing SOLID code

This part builds on the foundation laid in Part I. Each chapter is devoted to examining

one principle of SOLID. The emphasis in these chapters is on practical examples for

implementing the principles, rather than solely on the theory of why. By placing each

example in a real-world context, the chapters in this part of the book clearly demon-

strate the utility of SOLID.

■

Chapter 5: The single responsibility principle This chapter shows how to

implement the single responsibility principle in practice by using the Decorator

and Adapter patterns. The outcome of applying the principle is an increase in

the number of classes and a decrease in the size of those classes. The chapter

shows that, in contrast with monolithic classes that provide extensive features,

these smaller classes are more directed and focused on solving only a small part

of a larger problem. It is in their aggregation that these classes then become

more than the sum of their parts.

■

Chapter 6: The open/closed principle The open/closed principle (OCP) is

simply stated, but it can have a signicant impact on code. It is responsible for

ensuring that code that follows SOLID principles is only appended to and never

edited. This chapter also discusses the concept of predicted variation in relation

to OCP and explores how it can help developers identify extension points for

further adaptability.

■

Chapter 7: The Liskov substitution principle This chapter shows the posi-

tive effects that result from applying the Liskov substitution principle on code,

particularly the fact that the guidelines help enforce the open/closed principle

and prevent the unintended consequences of change. Contracts—through

From the Library of Ida Schander

www.it-ebooks.info

ptg14200592

Introduction xix

preconditions, postconditions, and data invariants—are covered by using the

Code Contracts tooling. The chapter also describes subtyping guidelines such

as covariance, contravariance, and invariance, along with the negative impact

of breaking these rules.

■

Chapter 8: Interface segregation Not only should classes be smaller than

they commonly are, this chapter shows that interfaces are, similarly, often too

big. Interface segregation is a simple practice that is often overlooked; this

chapter shows the benets of limiting interfaces to the smallest size possible,

along with the benets of working with smaller interfaces. It also explores the

different reasons that might motivate the segregation of interfaces, such as

client need and architectural need.

■

Chapter 9: Dependency injection This chapter contains the cohesive glue

that holds together the rest of the features in the book. Without dependency

injection (DI), there is a lot that would not be possible—it is really that impor-

tant. This chapter contains an introduction to DI and a comparison of the differ-

ent methods of implementing it. The chapter includes discussions on managing

object lifetimes, working with Inversion of Control containers, avoiding common

anti-patterns relating to service location, and identifying composition roots and

resolution roots.

Part III: Adaptive sample

This part uses a sample application as a way of tying together the rest of the book.

Although there is a lot of code in these chapters, there is ample accompanying explana-

tion. Because this book is about working in an Agile environment, the chapters map to

Scrum sprints, and all work is the result of backlog items and client change requests.

■

Chapter 10: Adaptive sample: Introduction This rst chapter describes

the application that is to be developed: an online chat application developed

in ASP.NET MVC 5. A brief design is provided as a guideline for the planned

architecture, in addition to an explanation of the features on the backlog.

■

Chapter 11: Adaptive sample: Sprint 1 Using a test-driven development

(TDD) approach, the rst features of the application are developed, including

viewing and creating chat rooms and messages.

■

Chapter 12: Adaptive sample: Sprint 2 The client, inevitably, makes some

changes to the requirements of the application, and the team accommodates

those changes through adaptive code.

From the Library of Ida Schander

www.it-ebooks.info

剩余432页未读，继续阅读

vanridin

粉丝: 108
资源: 1187

构建灵活代码：C#中的适应性设计模式与SOLID原则

Adaptive Code via C#

Adaptive Code via C# 无水印pdf

Adaptive code via C#

Adaptive Code via C# epub

adaptive code in C sharp

C# 敏捷开发实战：基于 Adaptive Code

C#适应性代码：运用设计模式与SOLID原则的敏捷编程

YOLOv3-训练-修剪.zip

毕业设计&课设_智能算法中台管理系统.zip

YOLO v2 的实现，用于在检测层内直接进行面部识别 .zip

最新资源