Uh-oh, it looks like your Internet Explorer is out of date.

For a better shopping experience, please upgrade now.

Agile Principles, Patterns, and Practices in C# / Edition 1

Agile Principles, Patterns, and Practices in C# / Edition 1

4.7 4
by Robert C. Martin

See All Formats & Editions

ISBN-10: 0131857258

ISBN-13: 9780131857254

Pub. Date: 08/03/2006

Publisher: Prentice Hall

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,


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.

Product Details

Prentice Hall
Publication date:
Robert C. Martin Series
Edition description:
Sales rank:
Product dimensions:
7.20(w) x 9.40(h) x 1.70(d)

Table of Contents

Forewords xix

Preface xxiii

Acknowledgments xxxi

About the Authors xxxiii

Section I: Agile Development 1

Chapter 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 101

Chapter 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 332

Monostate 336

Conclusion 343

Bibliography 343

Chapter 25: Null Object 345

Description 345

Conclusion 348

Bibliography 348

Chapter 26: The Payroll Case Study: Iteration 1 349

Rudimentary Specification 350

Analysis by Use Cases 351

Reflection: Finding the Underlying Abstractions 360

Conclusion 363

Bibliography 363

Chapter 27: The Payroll Case Study: Implementation 365

Transactions 366

Main Program 408

The Database 409

Conclusion 411

About This Chapter 411

Bibliography 412

Section IV: Packaging the Payroll System 413

Chapter 28: Principles of Package and Component Design 415

Packages and Components 416

Principles of Component Cohesion: Granularity 417

Principles of Component Coupling: Stability 420

Conclusion 435

Chapter 29: Factory 437

A Dependency Problem 440

Static versus Dynamic Typing 441

Substitutable Factories 442

Using Factories for Test Fixtures 443

Importance of Factories 444

Conclusion 445

Bibliography 445

Chapter 30: The Payroll Case Study: Package Analysis 447

Component Structure and Notation 448

Applying the Common Closure Principle (CCP) 450

Applying the Reuse/Release Equivalence Principle (REP) 452

Coupling and Encapsulation 454

Metrics 455

Applying the Metrics to the Payroll Application 457

The Final Packaging Structure 463

Conclusion 465

Bibliography 465

Chapter 31: Composite 467

Composite Commands 469

Multiplicity or No Multiplicity 470

Conclusion 470

Chapter 32: Observer: Evolving into a Pattern 471

The Digital Clock 472

The Observer Pattern 491

Conclusion 493

Bibliography 494

Chapter 33: Abstract Server, Adapter, and Bridge 495

Abstract Server 496

Adapter 498

Bridge 503

Conclusion 505

Bibliography 506

Chapter 34: Proxy and Gateway: Managing Third-Party APIs 507

Proxy 508

Databases, Middleware, and Other Third-Party Interfaces 526

Table Data Gateway 528

Using Other Patterns with Databases 539

Conclusion 541

Bibliography 541

Chapter 35: Visitor 543


Acyclic Visitor 548

Decorator 560

Extension Object 565

Conclusion 576

Bibliography 577

Chapter 36: State 579

Nested Switch/Case Statements 580

Transition Tables 584

The State Pattern 586

Classes of State Machine Application 598

Conclusion 602

Bibliography 602

Chapter 37: The Payroll Case Study: The Database 603

Building the Database 604

A Flaw in the Code Design 605

Adding an Employee 607

Transactions 618

Loading an Employee 623

What Remains? 636

Chapter 38: The Payroll User Interface: Model View Presenter 637

The Interface 639

Implementation 640

Building a Window 650

The Payroll Window 657

The Unveiling 669

Conclusion 670

Bibliography 670

Appendix A: A Satire of Two Companies 671

Rufus Inc.: Project Kickoff 671

Rupert Industries: Project Alpha 671

Appendix B: What Is Software? 687

Index 699

Customer Reviews

Average Review:

Post to your social network


Most Helpful Customer Reviews

See all customer reviews

Agile Principles, Patterns, and Practices in C# 4.8 out of 5 based on 0 ratings. 4 reviews.
PaulGBrown More than 1 year ago
One of the few tech books I have read from cover-to-cover. The book explains Agile principles from a reality perspective. I really enjoyed reading someone who understood that getting the code done (and done well) is the most important task versus producing mounds of paperwork.
Guest More than 1 year ago
In one sense, the book covers no new ground. The Agile principles and patterns discussed here have been well explained for two other languages, Java and C++, especially by Robert Martin in an earlier book. What is offered here is a recasting in terms of C#. Which however has far fewer practitioners than the other languages. Some sections of the book are mostly independent of any language. Take the chapter on state diagrams for documenting finite state machines as one example. Or the other chapters on object diagrams, use cases, sequence diagrams and class diagrams. Some of these do have example code in C#. But inherently, they tend to stand above any language. Some principles are quite useful, albeit perhaps to an advanced programmer. A good example is the chapter on Interface Segregation Principle. Basically, it's about how an interface can grow, if there are several child classes that implement it. The problem is when some classes need routines added to the interface, that other classes do not. So we get a fat interface. This creates a cross-coupling that is unneeded, and a potential source of errors. Something that you should try to minimise, for long term robustness and ease of code maintenance.
Anonymous More than 1 year ago
Anonymous More than 1 year ago