I hate this book, it is poorly written and I hate challenge projects. The explanations are not very clear. The Head Start Designj Patterns book is much better, though written in java is easy to convert to c#.
Save your money and buy the Head start book.

I just read a few chapters on it. The way this book is written is that the author shows you what each pattern is and then challanges you with "Challange" questions. I hate those challange questions since the answers are in the back of the book. Flipping back and forth to check the answers interrupted my thought process so I gave up on the challanges. I wish the author includes the answers right after the each challenge. I bought this book to learn, not to be challenged, been challenged enough during college already. Anyways, if you like to read books with quizes and challanges between sections or chapters, then I guess this book might be for you.

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.

This is a really great book and gives you an easy way to get into design patterns for C#. The code samples are very easy to understand but cover quite everything in design patterns. The author tries to show the reader where .NET implements those design patterns and how they could have been implemented in a more powerful way.

The writing style is clumsy and stands in the way of the material. Avoid this book.

I thought the book was great. It introduced patterns with a semi explanation of how thier implemented in the real world. It also explain why and how of each pattern.

Its not an introduction to programming so the "runnable" code isnt really needed.

I enjoyed the challenges because it re-enforces what your learning.

Like the books says this is meant for the icing on the cake for developers. Not a taining session on how to program .NET.

The book in my opinion is excellent. And does just what its intent says. An overview of design patterns.

The reviews above are simply expecting this book to teach them fundamentals they should already know before reading this book.

If you dont understand delegates, oop best practices, and .NET then get the application framework book first before reading this.

Nick

The book explains why and where you should apply which patterns with diagrams for a beginner which is a good approach. For practicallity, there section explaining and demonstrating delgates was the best book I have seen. There is lots of non-runable code eg. chain of responsibility , flyweights which forced me to refer to other c# patterns books. Some other topics were just too dificult to follow like the momento, template and GUI kits.Again I had to refer to the James W. Cooper c# pattern book and examples. This was definelty a tough book to grasp

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.

The book is clearly written and well organized. If you have specific patterns in mind then you should browse the table of contents and make sure this book covers the patterns that interest you. I thought the book should have contrasted the patterns against one another better, focusing on why use a particular pattern at all and why select it over others. Deciding which patterns to write about and how to structure the example code must be a challenge when writing a book on design patterns. Remember that design patterns books teach design patterns to software designers. It is not a programming book. I was already familiar with design patterns and C# when I read this so much of it was familiar already. Unlike some other books, the pattern examples simple enough you can use it as pattern resource even without string C# skills.

The book is more like a supplement to the classic "Design Patterns" by the Gang-of-Four. But it doesn't explain the pros and cons of each design pattern, and its examples aren't solid and don't help to lead you to the point. It has quite some coverage on rockets and fireworks and I found them more distractive than helpful. Not recommended. Instead, people should just go and read the classic book by GoF again.

chapter on Bridge is a disaster! Few sentences on design patterns and many on fireworks. Page 68 what in blazes is a handshaking machinemanager? Poor writing!
Authors: Before you publish a book, have a neophyte read the book! I'll do it if the subject interests me.
I mean a neophyte who is not a "yes" man!

A coherent application would help but not this scattered mess on fireworks!

What is this? You say I should deduce what the man is saying? Then I should just write my own book. By the way, the GOF book gets a C- from me. Poorly written. I ordered the code and had to work extensively on it to make it even compile. At least oozinoz builds with some minor alterations.

Basically, it's a good book on design patterns in C# language on the market, But Challenges really ruin this book.

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.


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.

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.

If you're a "notch above beginner" in regard to patterns (like me), then this is not the book for you. How strange that something as concepually simple as patterns can be so difficult to weave into applications. This book doesn't help. Steve chooses to use an arcane fireworks company as the standard example and then adds unnecessary complexity by incorporating complex code. (At one point, Steve goes into the calculus of fireworks trajectory!) Very frustrating to struggle with the application of patterns when the sample code itself is mindboggling.

Every once in a while I pick the book up to remind me how incompetent I am. I don't like books that make me feel that way.

Look into O'Reilly's "Head First Design Patterns" instead.

Let's get real. When talking about C# and Design Patterns, there are so many people with different levels and areas of experties. Some knows VB.NET well and nothing about C# and Design Patterns, some knows Java and Design Patterns well but nothing about C#, some knows nothing well, ...

So, who will benefit from this book most?
For people knows about Design Patterns but not C# and .NET, you will learn how C# implements design patterns.
For people knows .NET but not Design Patterns, you will find this book more approachable than GoF. You can use this book as a supplement or introductory book for GoF's discussion.
For people knows nothing about .NEt and Design Patterns, this is probably not the book you should pick. Learn some .NET and OO stuff.

For me, I did some Java and design patterns in the paste. After reading this book, I have a deeper understanding of Design patterns, while I gain more knowledge of C#.

So, if you think you need to know more about design patterns, I would recommend this book without reservation.

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.

This book reminds me of the 'Numerical Recipes in ' 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.

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.

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.

Very well written and instructive - the book provides great insight into the standard design patterns and into C# language details (e.g. behaviour of C# constructors). Lots of problems to help you really think about and understand the topic. I also found the sample code (on the web site) very helpful both to really understand the patterns and a source of template coding for my own projects. It helped to have some other "explanation heavy" pattern references such as Shalloway's "Design Patterns Explained", Goddfedder's "Joy of Patterns".

This book is very well and clearly written, with to the point examples and figures.
I enjoyed reading it, and even more enjoyed learning new patterns, and recognising some of the patterns I already did use (though without knowing it had a name).
The book contains lots of "challenges" or questions, and if you try to answer them, you really get to understand the pro's and cons of every patterns... Of course, it contains all the answers, so you can check if you're thinking the right thing.

Steve, please continue writing about the other 77 patterns :)

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.

This book will serve you well whether you know
Patterns and are trying to learn C# or know C# and are trying to
understand Patterns better. It is not a replacement for the Design
Patterns Book or a good C+ reference, but it is an excellent companion for both.