Design patterns and application design generally is maybe the most debated subject in enterprise application development. One reason for this is that getting started with the design patterns isn't that easy, and the way in which you can implement them isn’t always so straightforward. One might say that the whole concept is very subjective.
With .NET the full capability of object-oriented programming came into the picture for most of developers using Microsoft products. Certainly, design patterns have existed for a long time and have played an important role, for example, in the Java world, but for new .NET developers this meant a lot of new features and a lot of new challenges at the same time. You can do much more with .NET than with previous Microsoft technologies, but it comes with a price--increased complexity. Design patterns have evolved over the time to help to keep things in order when applications become complex.
Design Patterns in C# is the latest book about design patterns and is targeted especially at the .NET developer audience. It updates the design pattern principles to .NET, utilizing .NET-specific features like delegates in demonstrating design pattern implementations. The book covers all the twenty-three "Gang of Four" patterns.
The book has 456 pages in 29 chapters and four appendixes. The book has a hard cover.
Part 1: Interface Patterns
2. Introducing Interfaces
Part 2: Responsibility Patterns
7. Introducing Responsibility
12. Chain of Responsibility
Part 3: Construction Patterns
14. Introducing Construction
16. Factory Method
17. Abstract Factory
Part 4: Operation Patterns
20. Introducing Operations
21. Template Method
Part 5: Extension Patterns
26. Introducing Extensions
C. Oozinoz Source
D. UML at a Glance
The publisher, Addison-Wesley has a web site for the book at:
The author has a web site for the book at:
Maybe the greatest thing in this book is its structure. It is separated very cleanly and logically into chapters. Each and every chapter is built around its main topic, the current design pattern in scope, and therefore the subject goes on very fluently. The way in which topics are covered is uniform, making the book generally a pleasure to read. The basic structure is to start with a brief introduction to the pattern, introduce the challenges which this particular pattern can solve and then go on to an implementation example. Very simple and works very well.
When it comes to the content, the good thing is that the book doesn't try to tell too much about the subject and avoids repetition pretty well. The introduction and coverage of general theory related to design patterns are top quality. One can say that the book tells just enough to get you familiar with design patterns, but it won't even try to cover everything, which is a good decision, because the main red line with the book could easily suffer if it would try to cover too much.
And maybe it's not the most important thing, but a book with a hard cover usually gives good impression right away.
Unfortunately the biggest downside with the book is its practical side, as seen in the example application, which tries to bring theory into practice. While technically the application is okay and shows design patterns in pure use, it's not the easiest to understand, which might seem to be irrelevant to pattern implementation.
However, in my opinion, it is relevant to understand the line in which patterns are useful and in which you need to make compromises. Unfortunately, making compromises is reality, and I think it should apply to the teaching and learning material from the beginning. In that sense I would have expected more from this book.
The example application is built around a fictional Oozinoz company that manufactures and sells fireworks and puts on fireworks displays. The example application covers things related to the company's business area like rockets and calculating flight paths and so on. It is too pure, too theoretical as it is just built to demonstrate design patterns. I'd say this isn’t a major failure, but a real-word example would have been better.
As a whole the book is interesting to read and offers new things from a theoretical view. As a learning experience, it is invaluable even if the practical side is bit clumsy. That is often a problem with design pattern teaching materials. If you are in need for a good design pattern book and need it for .NET use, go and get this one.