Spotlight customer reviews:
|
Customer Rating:  
Summary: Somewhat of a let down
Comment: As with all books on patterns, I had high expectations from this book. I was really hoping that the author would have introduced new patterns utilizing new 3.0 language features that I have not yet thought of on my own, but was disappointed to see that the book is mostly another poorly written book on design patterns that happened to use C#.
After realizing that the book was what it was, I was hoping that she would have done something a bit on the cutting-edge side of things by fusing new C# 3.0 language constructs and design patterns, but again, disappointed. The application of C# 3.0 features throughout the book seemed to be more of a showcase ("hey look what I can do") as opposed to practical or necessary.
If you understand that this book is just another patterns book and doesn't introduce new patterns or really take advantage of new C# 3.0 language features, this book is ok. On a positive note, the book is a simple read. But if you're looking for a really solid book on patterns for the bookshelf, the gang of four patterns book (1994) is still the way to go.
Customer Rating:
Summary: Not just sloppy - but wrong.
Comment: I bought several copies of this book to teach my development team design patterns. I have a copy of and like the Head First design patterns book, but my guys wanted to learn some of the new C# 3.0 features and judging from the other reviews I thought this would be a decent book.
Boy was I wrong. Do not trust the positive reviews. The examples and coresponding code samples are flat wrong. I don't mean code won't compile, I mean they don't teach the purpose of the design patterns or blatently defeat the pupose of them. I am only up to chapter 3 and I am having to create cheatsheets that show how the patter REALLY should work. If anyone is reading this and really wants to learn the design patterns, I would recommend the Head First or the original Gang of Four books. Beware, if you don't know design patterns and use this to learn you will be shooting yourself in the foot.
Customer Rating:
Summary: Learn Classic Design Patterns In C# 3.0
Comment: 'C# 3.0 Design Patterns' covers the classic "gang of four" design patterns with a focus on C# 3.0 as the main language of choice. Spread over 11 chapters and ~300 pages, this book seems a tiny bit short considering the subject matter, but there is a enough here to make it work. All the patterns that you would expect are here, broken out and explained why and how they can be used. If you want to become a better programmer and add skills to your repertoire, this is a great resource to have by your side. If these classic patterns are followed and used correctly you will produce more efficient, cleaner, BETTER code, I guarantee it!!
***** HIGHLY RECOMMENDED
Customer Rating:
Summary: Good overview of Design Patterns using C# 3.0 but seems rushed
Comment: On one hand I like the book, I feel the layout and presentation of each pattern is well done, concise, yet you can grasp the main point of each pattern. Each pattern is explained, implemented, further examples are given, uses are explained and then each pattern is wrapped up with a series of exercises.
On the other hand, the book has many typos, the exercises are a very mixed bag and sometimes the explanation are incorrect or incomplete and it is hard to understand why the author really did what they did or the full implications. This really is a mar on an otherwise solidly presented book. The errors did make me dig into the details and I did learn more from my digging. So, if you are willing to work around these warts than you will learn something but for a beginner the level of frustration may not be worth it. For example the Observer pattern blog example, which uses events with a dictionary was not explained in enough detail. If you looked, you would have found something along the lines of the MSDN article "How to: Use a Dictionary to Store Event Instances (C# Programming Guide)" but you had to look for it.
This also applies to the C# 3.0 features that are presented in the book, again citing the example above. The Mediator pattern has a sidebar on delegates and events and it explains in a very high level what you need to know to implement events stored in a dictionary but unless you use sources outside the book you will be missing out on a lot.
The exercises are varied, some are excellent and they really force you think about what the pattern is about and sink your teeth into the details. Others just seem like they are there to fill space, others do not seem thought out well enough. For example in the Decorator pattern one of the exercises asks you to decorate System.Console but you can not do it using the methods presented. You can use a wrapper but that is not really decorating, so you are left wondering what the real intent was or even worse did you miss some key point.
So overall, even though the book does have warts, it definitely useful, you will learn about the GOF design patterns and come away with some useful knowledge on C# 3.0 and beyond that. I would suggest using the book with a critical mind, try to pick apart the examples and experiment with them, test the authors claims and find the mistakes. My impression is that this book needed another revision and some sections feel like they were in the process of being revised but the book was shipped before the process was done.
If I could I would give the book 3.5 stars, it is still very useful but the warts are painful and coming from O'Reilly that is disappointing. Some have mentioned the "Head First Design Patterns", also by O'Reilly. I have to say that if you want to learn design patterns from a Java perspective I would probably recommend that book instead.
BTW, A previous reviewer had claimed the Observer pattern example did not work but I did not have any problems getting that example to work.
Customer Rating:
Summary: Buy Head First Design Patterns Instead
Comment: I was disappointed with this book. The author does not use standard C# coding; it looks more like Java. Her code examples use inappropriate global variables. I couldn't get the Observer example, which uses C# delegates and events, to work unless I used a global event variable. Bad form in my opinion. Visual Studio is not used to leverage the coding.
I was far more satisfied with Head First Design Patterns, even if the examples were in Java. I learned a lot converting them to C#.
|
|
|
