Customer Reviews

Design Patterns in C#

5 star:		(10)
4 star:		(6)
3 star:		(7)
2 star:		(4)
1 star:		(3)

 

 

This book reminds me of the 'Numerical Recipes in <x>' books. They were the thin adjunct books that accompanied Numerical Recipes which showed the examples implemented in various languages. The books were no good on their own, you needed Numerical Recipes to understand them. This book has the same problem. It doesn't introduce the patterns from scratch, it assumes that you have read the GoF book and that you can use it as the base source material.

That being said the author puts together, succinctly, with both diagrams and code, C# examples for all of the GoF design patterns. Even though in some cases there is very little code because the patterns have been integrated into the structure of the .NET framework.

I think this book is worth a look for anyone writing C# on a daily basis and who is a patterns fan. It's something you need to evaluate before you buy because, frankly, you may already know most of what you are going to see.

I really liked this book.

My background was in VB6 and classic ASP, until just over two years ago. I was introduced to C# and I've never looked back.
Reading about C# best practices led me into design patterns and that naturally led me to this book. It was the first book I've read on patterns (aside from a few articles online.)

Concise - Metsker doesn't waste my time with unnecessary text (such as lame jokes or repetitive text). If I don't get something the first time, I go back and read it over.

Readable - The information in the book is dense, and there are certainly sections that may be confusing initially. However the book thoughtfully organized, the spacing and layout are comfortable, the author's voice reminiscent of a friendly college professor

Specific - His implementation of patterns take advantage of C# specific features. This is important, and I would not have recognized this without the input of C++ developer.</li>


In addition, this book helped to clarify a number of Object Oriented and Component Oriented concepts (such as delegates, interfaces, and iterators). Likewise, it shed light on the .NET FCL (streams and enumerators)

Regarding the exercises in the book; I was irritated with them at first, however I found that they were really useful for making the concepts stick once I quit being lazy. On the flipside, the book is quite useable even if you skip over them.

The only real negative is the metaphor of the fireworks company. It's not intuitive and it takes a while to sink in.

Pros

Steven knows what he's talking about. All patterns are nicely organized. I really liked chapter introductions and summaries because they were at times much clearer than chapter content itself. Small typos here and there didn't bother me that much. Overall, the book is proof-read quite well.

Cons

Each chapter presents a number of challenges, or quizzes. They appear intermittently with text and therefore distract you from the discussion each time because their solutions are listed in the back and you have to flip back and forth to follow code.

In a couple of places Steven throws a quiz at you and afterwards presents the subject at hand. Normally, you present material first and then quiz. Doing it the other way around is quite a strange educational technique.

Steven is an author of a number book on Java, and it shows in his C# code. Nothing wrong with Java per se, but c'mon! For example, he refers to the book Concurrent Programming in Java as an excellent resource when discussing multithreaded programming in .NET.

The singleton implementation found in this book is downright wrong! It may lead to deadlocks and is not thread-safe. You can find a more efficient implementation of a singleton with a double-check lock at Microsoft's Patterns and Practices.

Conclusion

The book *is* valuable. I didn't think it was a waste of money. Still, it fails to be the best book on the subject of Design Patterns in C# around.

C# is still a relatively new language. Certainly younger than Java or C++, which are the 2 most common OO languages. So chances are, some people coming to this book are still clumsy in C#. But I think it is also reasonable to say that if you are contemplating ANY book on design patterns, that you are fluent in at least one language.

Strictly, a purist might say that design patterns do not need to refer to a specific language. They are a level above code. But pragmatically, to understand them, it helps to instantiate examples in a language.

All this means that the book is good for an experienced developer who is still new to C#. You understand why design patterns are important. You can use the book to bootstrap your fluency in C# by studying the examples and tackling the supplied problems.

If you are indeed an experienced developer in another language, you might find the narrative more appealing than that in a Dummies-type book. The level of discussion that Metsker supplies is more advanced and challenging. More interesting.

Hey! He also gives answers to the problems.

I've read several books on design patterns (including the classic "Gang of Four" work) and this is by far the best I've seen. What is unique about this book is its concise focus on the practical application of each of the 23 classic design patterns. The examples are short and can be written and tested quickly, yet cover real world programming issues that are encountered every day. "Challenges" (with solutions) are interspersed throughout the text to reinforce the concepts and help you bridge the gap between the specific example and a more general understanding.

If you've been fascinated with the elegance and power of design patterns, yet sometimes struggle with exactly how and where to apply them, then the "light" will go on after reading this book.

Get this book first, then grab the classic "Gang of Four" work. You'll find your understanding of both books and design patterns in general greatly enhanced.

I had high expectations of "Design Patterns In C#" by Steven John Metsker but unfortunately the book didn't live up to them. This book is part of the "Software Patterns Series" of books that was started off by the classic "Design Patterns" by "The Gang of Four"(GoF), as they are known. That book is amazing and should be part of every software developer's library.

Metsker's book assumes the reader has studied the GoF book and is knowledgeable in the basic 23 design patterns covered in it. Therefore, this book is intended to be a supplement to the original classic, expanding on it to show implementations in C# and leaving the in-depth rational of the design patterns to be described in the original. I feel like this was the correct approach to take because the original masterpiece does such a good job at introducing the subject of design patterns and giving the reader a solid foundation.

My main complaint about "Design Patterns In C#" is the "challenges" this book includes throughout the text. I have no problem with exercises for the reader to try but the way this book presents them makes the actual text useless as a reference.

In many chapters, the major UML diagram and/or coding example showing how to implement a given design pattern is left with missing parts for the reader to fill in. This book's audience is experienced developers, who are looking for the author's opinion on the proper ways to implement a given design pattern using all the features of C#. Because of the "challenges" sections, the author is leaving out the exact parts of the book the developer needs. It is very frustrating to have to consult an appendix every couple of pages before making sense of the text following a "challenge". This book should have left out the "challenges" and instead imitated the original "Design Patterns" book by becoming a no nonsense reference for software architects.

My other, smaller, complaint about this book is that it uses one large source code base for its examples instead of giving the reader a separate, small example for every pattern. If the author had chosen to use a small example for each chapter then they would have remained more independent of each other and easier to use as a reference. But, as I covered above, the author pretty much killed any chance of this book being a useful reference.

This book wasn't all bad. The author did do a good job of showing which specific features of the C# language, such as interfaces, applied well to the various design patterns and made their implementations cleaner. I also liked that the author used UML instead of the older OMT used by the GoF book. To be fair to the original book, UML was not standardized at the time of its writing. Overall, I would recommend against purchasing "Design Patterns In C#" because of its "challenges" sections.

The first thing you should know is that this book is not really intended to teach you the GOF patterns -- read the GOF book for that. That said, it does do a decent job of translating the GOF patterns into C#.

My main gripe, and it is a big one, is that this book is *very* difficult to read because half of the relevant material is in the form of "challenges" whose answers are in an appendix at the back of the book. Please note that these "challenges" are not supplemental exercises that can be skipped -- they contain key information that is needed to understand the implementation of the pattern. Having to jump back and forth on nearly every page make the book almost unusable.

This book may work well in a human-taught course but I down-rate it for self study and reference. I found it tedious because content is spread over several pages when it could have been effectively presented much more concisely. The flow of information is interrupted by frequent "Challenge" exercises with solutions in the Appendix: normally I would applaud efforts to engage the reader's thinking, but although the challenges were pretty straightforward checkups on understanding I found them very distracting. When I am trying to learn something I really want the content presented directly and clearly up front.

I am currently slogging my way through this text, and while the experience has been instructive, it has not been pleasurable.

The book has great value in that it demonstrates design patterns using C# code, and it includes other useful information such as a discussion of C# delegates and interfaces. I would recommend it to developers who are programming in C# and want to become better at applying design patterns in that language. It's not the best introduction to design patterns for beginners - I think Gamma's book is better for that. Also, it's not the best intro to C#. This is a book that is targeted to intermediate/advanced programmers.

Regardless of skill level, it is a difficult read. As others have mentioned, the practice of introducing new information in the form of quizzes on virtually every page is very obnoxious, requiring one to constantly refer to the material at the back of the book in order to follow the narrative in the text. Furthermore, the sentence style is terse, often lacking modifiers such as adjectives and adverbs, so that one has to infer meaning through context without really being sure of what the author meant.

Fine book for the experienced C# developer wanting to enhance their understanding of design patterns ala Java. (I've picked up many "new" ideas!) But this slant is not without its pitfalls. For example, the recommendation for implementing a singleton may be a best practice in Java, but its a big no-no in .NET.