Agile Principles, Patterns, and Practices in C# (Robert C. Martin Series)

Agile Principles, Patterns, and Practices in C# (Robert C. Martin Series) Robert C. Martin Date: 2006-07-20   —   Book product page Rating:

Just recently, I wrote this blog post where I used the Monostate pattern to facilitate easier data binding in WPF applications. As mentioned in that blog post, I got the name for the pattern (but not the pattern itself) from this book.

I've read most of this book, skimming through some of the chapters in the beginning. Most of the chapters I was interested in were the pattern chapters themselves, which include:

• SRP - The Single Responsibility Principle
• OCP - The Open-Closed Principle
• LSP - The Liskov Substitution Principle
• DIP - Dependency Inversion Principle
• ISP - Interface Segregation Principle
• REP - Release-Reuse Equivalency Principle
• CCP - Common Closure Principle
• CRP - Common Reuse Principle
• ADP - Acyclic Dependencies Principle
• SDP - Stable Dependencies Principle
• SAP - Stable Abstractions Principle

There are some extremely useful principles of Agile design in there, especially the Liskov Substitution Principle, which I have running through my head more often than bad songs or reminders to pick up bread on the way home from work. If you are looking for a good book on Agile programming and design, and you already have a good OOP background and you are already a C# programmer, then this book is absolutely for you.

The problem with this book is that the authors of the book are obviously not C# programmers for their day jobs. I have a couple of really large gripes with this book:

1. The authors of the book regularly interchange the terms abstract base class and interface as if they mean the same thing. They do not mean the same thing, and they have entirely different impacts on design. Anyone reading this book who does not already have a really firm grasp on how C# interfaces differ from C# abstract base classes both technically as far as the CLR is concerned and from a design point of view - will be horribly confused.
2. The authors are guilty of  "stacking the deck". By this I mean that many of their examples are flawed. All of these patterns are extremely good patterns, and good examples of why you would want to use these patterns are easy to find. However, in many cases throughout this book, the authors will show you a functional programming legacy C code sample as an example of the "bad", and a fully OOP C# code sample as an example of the "good". What people (including me) want is a C# example of what a bad implementation looks like and what a C# example of what a good implementation looks like. While the authors do provide this, I was put off by the sheer amount of raw C contained in this book, especially given the fact that this book includes C# in the title.
3. The authors, while incredibly bright guys who obiously know what they're doing, occasionally miss a couple aspects of C# and .NET in general that would make for better samples. They completely neglect Generics in all samples, despite them being useful in a couple of the above mentioned patterns. In addition, they add needless complexity to a couple samples in the book to show the wrong way to do something, when no programmer who knows C# would do it that way to begin with (this is related to gripe #2). For example, delegates and events could have been used in one example illustrating the Dependency Inversion Principle and they weren't - making the example more difficult to follow and even more difficult to justify the refactoring.

To recap: If you already have strong programming skills, strong OOP skills, and a really good working knowledge of C#, then you can overlook the gripes I have about the book and get a flaming truckload of really good patterns, practices, and ideas to make your code and your design better.

If you are a novice C# programmer looking for some pattern advice, I recommend strongly that you skip this book. It will confuse you and perhaps even weaken your core abilities with C# because of all the incorrect syntax and terminology thrown around.

tags: book  review  patterns  practices  principles  agile  xp  extreme  programming  

links: digg this    del.icio.us    technorati    reddit