Agile Principles, Patterns, and Practices in C#

*Forewords xixPreface xxiiiAcknowledgments xxxi**About the Authors xxxiii*Section I: Agile Development 1Chapter 1: Agile Practices 3 The Agile Alliance 4

Principles 8

Conclusion 10

Bibliography 11 Chapter 2: Overview of Extreme Programming 13 The Practices of Extreme Programming 14

Conclusion 22

Bibliography 22 Chapter 3: Planning 23 Initial Exploration 24

Release Planning 25

Iteration Planning 25

Defining “Done” 26

Task Planning 26

Iterating 27

Tracking 28

Conclusion 29

Bibliography 29 Chapter 4: Testing 31 Test-Driven Development 32

Acceptance Tests 36

Serendipitous Architecture 37

Conclusion 38

Bibliography 39 Chapter 5: Refactoring 41 A Simple Example of Refactoring: Generating Primes 42

Conclusion 53

Bibliography 54 Chapter 6: A Programming Episode 55 The Bowling Game 56

Conclusion 98

Overview of the Rules of Bowling 99 Section II: Agile Design 101Chapter 7: What Is Agile Design? 103 Design Smells 104

Why Software Rots 107

The Copy Program 108

Conclusion 113

Bibliography 114 Chapter 8: The Single-Responsibility Principle (SRP) 115 Defining a Responsibility 117

Separating Coupled Responsibilities 119

Persistence 119

Conclusion 119

Bibliography 120 Chapter 9: The Open/Closed Principle (OCP) 121 Description of OCP 122

The Shape Application 124

Conclusion 132

Bibliography 133 Chapter 10: The Liskov Substitution Principle (LSP) 135 Violations of LSP 136

Factoring Instead of Deriving 148

Heuristics and Conventions 150

Conclusion 151

Bibliography 151 Chapter 11: The Dependency-Inversion Principle (DIP) 153 Layering 154

A Simple DIP Example 157

The Furnace Example 160

Conclusion 161

Bibliography 162 Chapter 12: The Interface Segregation Principle (ISP) 163 Interface Pollution 163

Separate Clients Mean Separate Interfaces 165

Class Interfaces versus Object Interfaces 166

The ATM User Interface Example 169

Conclusion 174

Bibliography 175 Chapter 13: Overview of UML for C# Programmers 177 Class Diagrams 180

Object Diagrams 182

Collaboration Diagrams 183

State Diagrams 184

Conclusion 185

Bibliography 185 Chapter 14: Working with Diagrams 187 Why Model? 187

Making Effective Use of UML 189

Iterative Refinement 194

When and How to Draw Diagrams 200

Conclusion 202 Chapter 15: State Diagrams 203 The Basics 204

Using FSM Diagrams 208

Conclusion 209 Chapter 16: Object Diagrams 211 A Snapshot in Time 212

Active Objects 213

Conclusion 217 Chapter 17: Use Cases 219 Writing Use Cases 220

Diagramming Use Cases 222

Conclusion 223

Bibliography 223 Chapter 18: Sequence Diagrams 225 The Basics 226

Advanced Concepts 232

Conclusion 241 Chapter 19: Class Diagrams 243 The Basics 244

An Example Class Diagram 247

The Details 249

Conclusion 258

Bibliography 258 Chapter 20: Heuristics and Coffee 259 The Mark IV Special Coffee Maker 260

OOverkill 279

Bibliography 292 Section III: The Payroll Case Study 293 Rudimentary Specification of the Payroll System 294

Exercise 295 Chapter 21: Command and Active Object: Versatility and Multitasking 299 Simple Commands 300

Transactions 302

Undo Method 304

Active Object 305

Conclusion 310

Bibliography 310 Chapter 22: Template Method and Strategy: Inheritance versus Delegation 311 Template Method 312

Strategy 319

Conclusion 324

Bibliography 324 Chapter 23: Facade and Mediator 325 Facade 325

Mediator 327

Conclusion 329

Bibliography 329 Chapter 24: Singleton and Monostate 331 Singleton 332Robert C. Martin has been a software professional since 1970 and an international software consultant since 1990. He is founder and president of Object Mentor, Inc., a team of experienced consultants who mentor their clients in the fields of C++, Java, OO, Patterns, UML, Agile Methodologies, and Extreme Programming.

Micah Martin works with Object Mentor as a developer, consultant, and mentor on topics ranging from object-oriented principles and patterns to agile software development practices. Micah is the cocreator and lead developer of the open source FitNesse project. He is also a published author and speaks regularly at conferences.

Texte du rabat

With the award-winning book Agile Software Development: Principles, Patterns, and Practices, Robert C. Martin helped bring Agile principles to tens of thousands of Java and C++ programmers. Now .NET programmers have a definitive guide to agile methods with this completely updated volume from Robert C. Martin and Micah Martin, Agile Principles, Patterns, and Practices in C#.

This book presents a series of case studies illustrating the fundamentals of Agile development and Agile design, and moves quickly from UML models to real C# code. The introductory chapters lay out the basics of the agile movement, while the later chapters show proven techniques in action. The book includes many source code examples that are also available for download from the authors' Web site.

Readers will come away from this book understanding

• Agile principles, and the fourteen practices of Extreme Programming
• Spiking, splitting, velocity, and planning iterations and releases
• Test-driven development, test-first design, and acceptance testing
• Refactoring with unit testing
• Pair programming
• Agile design and design smells
• The five types of UML diagrams and how to use them effectively
• Object-oriented package design and design patterns
• How to put all of it together for a real-world project
  Whether you are a C# programmer or a Visual Basic or Java programmer learning C#, a software development manager, or a business analyst, Agile Principles, Patterns, and Practices in C# is the first book you should read to understand agile software and how it applies to programming in the .NET Framework.

Résumé
Presents a series of case studies illustrating the fundamentals of Agile development and Agile design, and how it applies to programming in the .NET Framework. This book includes chapters that lay out the basics of the agile movement and show proven techniques. It also includes many source code examples.

Contenu

• Chapter 1: Agile Practices
• Chapter 2: Overview of Extreme Programming
• Chapter 3: Planning
• Chapter 4: Testing
• Chapter 5: Refactoring
• Chapter 6: A Programming Episode
• Chapter 7: What Is Agile Design?
• Chapter 8: The Single-Responsibility Principle (SRP)
• Chapter 9: The Open/Closed Principle (OCP)
• Chapter 10: The Liskov Substitution Principle (LSP)
• Chapter 11: The Dependency-Inversion Principle (DIP)
• Chapter 12: The Interface Segregation Principle (ISP)
• Chapter 13: Overview of UML for C# Programmers
• Chapter 14: Working with Diagrams
• Chapter 15: State Diagrams
• Chapter 16: Object Diagrams
• Chapter 17: Use Cases
• Chapter 18: Sequence Diagrams
• Chapter 19: Class Diagrams
• Chapter 20: Heuristics and Coffee
• Chapter 21: Command and Active Object: Versatility and Multitasking
• Chapter 22: Template Method and Strategy: Inheritance versus Delegation
• Chapter 23: Facade and Mediator
• Chapter 24: Singleton and Monostate
• Chapter 25: Null Object
• Chapter 26: The Payroll Case Study: Iteration 1
• Chapter 27: The Payroll Case Study: Implementation
• Chapter 28: Principles of Package and Component Design
• Chapter 29: Factory
• Chapter 30: The Payroll Case Study: Package Analysis
• Chapter 31: Composite
• Chapter 32: Observer: Evolving into a Pattern
• Chapter 33: Abstract Server, Adapter, and Bridge
• Chapter 34: Proxy and Gateway: Managing Third-Party APIs
• Chapter 35: Visitor
• Chapter 36: State
• Chapter 37: Th…